Add and load all three extensions in Chrome on Hugging Face Spaces

Dockerfile

@@ -2,6 +2,14 @@ FROM akashyadav758/chrome:latest
 
 USER root
 
+# Copy extensions into the container
+COPY chatgpt-free-api/gpt-extension /opt/gpt-extension
+COPY free-gemini-api/extension /opt/gemini-extension
+COPY flow-agent/extension /opt/flow-extension
+
+# Set correct permissions
+RUN chmod -R 755 /opt/gpt-extension /opt/gemini-extension /opt/flow-extension
+
 # Replace the start script with the non-root version
 COPY --chmod=755 start_hf.sh /start.sh
 

chatgpt-free-api/.gitignore

@@ -0,0 +1,13 @@
+# Binaries
+agent
+agent.exe
+
+# Private Session Cookies
+cookies.json
+
+# Logs & Debug
+*.log
+debug_poll.json
+
+# Local Output Files
+output/

chatgpt-free-api/README.md

@@ -0,0 +1,56 @@
+# ChatGPT Free API Agent
+
+A flat-structure Go server that connects with the Chrome extension (`gpt-extension`) to execute ChatGPT backend API requests directly from your authenticated browser session.
+
+## Setup & Running
+
+1. **Build & Run the Server:**
+   ```bash
+   go build -o agent .
+   ./agent
+   ```
+2. **Load Chrome Extension:**
+   - Open `chrome://extensions` in Chrome.
+   - Enable **Developer mode** (top-right).
+   - Click **Load unpacked** and select the `gpt-extension` folder (in the parent directory).
+3. **Login to ChatGPT:**
+   - Open `https://chatgpt.com/` and log in. The extension will automatically connect to the running Go agent (green status badge = connected).
+
+---
+
+## API Usage
+
+### 1. Send Chat Request
+```bash
+curl -X POST "http://127.0.0.1:9225/api/chat" \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "Why is sky blue?", "conversation_id": ""}'
+```
+
+### 2. Bulk Sequential Requests
+```bash
+curl -X POST "http://127.0.0.1:9225/api/chat/bulk" \
+  -H "Content-Type: application/json" \
+  -d '{"prompts": ["hello", "how are you"]}'
+```
+
+### 3. Edit Existing Message
+```bash
+curl -X POST "http://127.0.0.1:9225/api/chat/edit" \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "updated prompt", "conversation_id": "conv-id", "message_id": "msg-id", "parent_id": "parent-id"}'
+```
+
+### 4. Health & Cookie Status
+- **Health Check:** `GET http://127.0.0.1:9225/health`
+- **Cookie Status:** `GET http://127.0.0.1:9225/api/cookies/status`
+
+---
+
+## Testing
+
+Run the integration tests (requires agent running on port 9225):
+```bash
+./test.sh             # Run all tests (text, thread, bulk, image gen/edit)
+./test_image_only.sh  # Run only image generation/editing tests
+```

chatgpt-free-api/agent.go

@@ -0,0 +1,144 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"sync"
+	"time"
+)
+
+var (
+	activeConvMu sync.Mutex
+	activeConvID string
+)
+
+func getActiveConversationID() string {
+	activeConvMu.Lock()
+	defer activeConvMu.Unlock()
+	return activeConvID
+}
+
+func setActiveConversationID(id string) {
+	activeConvMu.Lock()
+	activeConvID = id
+	activeConvMu.Unlock()
+}
+
+func clearActiveConversationID() {
+	activeConvMu.Lock()
+	activeConvID = ""
+	activeConvMu.Unlock()
+}
+
+func Start() {
+	loadConfig()
+	LoadCookiesFromFile()
+
+	promptFlag := flag.String("prompt", "", "Prompt to send to ChatGPT after the extension connects")
+	onceFlag := flag.Bool("once", false, "Send the prompt, print the response, then exit")
+	timeoutFlag := flag.Duration("timeout", cfg.Timeout(), "Maximum time to wait for extension/response")
+	flag.Parse()
+
+	http.HandleFunc("/", handleWS)
+	http.HandleFunc("/health", handleHealth)
+	http.HandleFunc("/api/ext/callback", handleCallback)
+	http.HandleFunc("/api/ext/reload", func(w http.ResponseWriter, r *http.Request) {
+		extMu.Lock()
+		conn := extConn
+		extMu.Unlock()
+		if conn == nil {
+			writeJSONStatus(w, http.StatusServiceUnavailable, map[string]any{"ok": false, "error": "extension not connected"})
+			return
+		}
+		err := conn.WriteJSON(WSMessage{
+			Method: "reload_extension",
+		})
+		if err != nil {
+			writeJSONStatus(w, http.StatusInternalServerError, map[string]any{"ok": false, "error": err.Error()})
+			return
+		}
+		writeJSON(w, map[string]any{"ok": true, "message": "reload request sent"})
+	})
+	http.HandleFunc("/api/conversation", func(w http.ResponseWriter, r *http.Request) {
+		convID := r.URL.Query().Get("conversation_id")
+		if convID == "" {
+			writeJSONStatus(w, http.StatusBadRequest, map[string]any{"ok": false, "error": "conversation_id required"})
+			return
+		}
+		token, err := getSessionToken()
+		if err != nil {
+			writeJSONStatus(w, http.StatusServiceUnavailable, map[string]any{"ok": false, "error": err.Error()})
+			return
+		}
+		res, err := callChatGPTAPI(apiCallParams{
+			URL:    "https://chatgpt.com/backend-api/conversation/" + convID,
+			Method: "GET",
+			Headers: map[string]string{
+				"Authorization": "Bearer " + token,
+			},
+		}, cfg.APITimeout())
+		if err != nil {
+			writeJSONStatus(w, http.StatusInternalServerError, map[string]any{"ok": false, "error": err.Error()})
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(res.Status)
+		w.Write([]byte(res.Body))
+	})
+	http.HandleFunc("/api/chat", handleChat)
+	http.HandleFunc("/api/chat/bulk", handleChatBulk)
+	http.HandleFunc("/api/chat/edit", handleChatEdit)
+	http.HandleFunc("/api/chatgpt/test", handleChat)
+	http.HandleFunc("/api/sniffs", handleSniffs)
+	http.HandleFunc("/api/download", handleDownload)
+	http.HandleFunc("/v1/chat/completions", handleOpenAIChat)
+	http.HandleFunc("/api/cookies/status", func(w http.ResponseWriter, r *http.Request) {
+		writeJSON(w, map[string]any{
+			"ok":              true,
+			"has_cookies":     HasCookies(),
+			"last_sync":       GetLastCookieSync().Format(time.RFC3339),
+			"cookie_header_len": len(GetCachedCookieHeader()),
+			"extension_connected": isExtensionConnected(),
+		})
+	})
+
+	if *promptFlag != "" {
+		go runPromptFromCLI(*promptFlag, *timeoutFlag, *onceFlag)
+	}
+
+	log.Printf("ChatGPT Agent listening on http://%s", cfg.ListenAddr)
+	log.Println("Reload the ChatGPT Browser Bridge extension if it is not connected.")
+	log.Println("Endpoints: GET/POST /api/chat, POST /api/chat/bulk, POST /api/chat/edit, GET /api/sniffs, GET /health")
+	if err := http.ListenAndServe(cfg.ListenAddr, nil); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func runPromptFromCLI(prompt string, timeout time.Duration, once bool) {
+	log.Println("Waiting for extension API bridge connection...")
+	if !waitForExtension(timeout) {
+		log.Println("Extension did not connect before timeout")
+		if once {
+			os.Exit(1)
+		}
+		return
+	}
+
+	log.Printf("Sending prompt: %s", prompt)
+	text, _, err := sendChat(prompt)
+	if err != nil {
+		log.Printf("ChatGPT request failed: %v", err)
+		if once {
+			os.Exit(1)
+		}
+		return
+	}
+
+	fmt.Println(text)
+	if once {
+		os.Exit(0)
+	}
+}

chatgpt-free-api/api_bridge.go

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"log"
+	"os"
+	"regexp"
+	"strings"
+	"time"
+)
+
+var fileIDRegexp = regexp.MustCompile(`(file_[0-9a-fA-F]{32}|file-[a-zA-Z0-9_-]{24,36})`)
+
+func sendChat(prompt string) (string, string, error) {
+	return sendChatWithConversation(prompt, "", cfg.DefaultModel, cfg.DefaultThinkingEffort)
+}
+
+func sendChatWithConversation(prompt, conversationID, model, thinkingEffort string) (string, string, error) {
+	return sendChatWithConversationAndAttachments(prompt, conversationID, model, thinkingEffort, nil)
+}
+
+func sendChatWithConversationAndAttachments(prompt, conversationID, model, thinkingEffort string, attachments []FileAttachment) (string, string, error) {
+	var response, rawText, newConvID string
+	var err error
+
+	// ─── Try 1: Direct Go HTTP call using synced cookies (fastest, no extension needed) ───
+	if HasCookies() && len(attachments) == 0 {
+		log.Println("[chat] Attempting direct API call using synced cookies...")
+		response, rawText, newConvID, err = SendChatDirect(prompt, conversationID, model, thinkingEffort)
+		if err == nil {
+			log.Println("[chat] ✅ Direct API call succeeded!")
+			return processResponse(response, rawText, newConvID, prompt, attachments)
+		}
+		log.Printf("[chat] ⚠️ Direct API call failed: %v — falling back to extension", err)
+	}
+
+	// ─── Try 2: Extension full_conversation method (browser-based) ───
+	log.Println("[chat] Using extension full_conversation method...")
+	response, rawText, newConvID, err = sendChatViaFullConversation(prompt, conversationID, model, thinkingEffort, attachments...)
+	if err != nil {
+		return "", "", err
+	}
+
+	return processResponse(response, rawText, newConvID, prompt, attachments)
+}
+
+// processResponse handles post-processing: auto-download images, poll for async images
+func processResponse(response, rawText, newConvID, prompt string, attachments []FileAttachment) (string, string, error) {
+	// Auto-download any files found in the rawText or response
+	var rawFileIDs []string
+	rawFileIDs = append(rawFileIDs, fileIDRegexp.FindAllString(rawText, -1)...)
+	rawFileIDs = append(rawFileIDs, fileIDRegexp.FindAllString(response, -1)...)
+
+	// Dedup and filter file IDs (excluding any attachment IDs we uploaded)
+	uploadedIDs := make(map[string]bool)
+	for _, att := range attachments {
+		uploadedIDs[att.ID] = true
+	}
+	seen := make(map[string]bool)
+	var fileIDs []string
+	for _, id := range rawFileIDs {
+		if !seen[id] && !uploadedIDs[id] {
+			seen[id] = true
+			fileIDs = append(fileIDs, id)
+		}
+	}
+
+	log.Printf("[chat] Found %d new file ID(s) to download: %v", len(fileIDs), fileIDs)
+
+	if len(fileIDs) > 0 {
+		for _, id := range fileIDs {
+			registerFilePrompt(id, prompt)
+			name := getPromptFilename(prompt, id)
+			log.Printf("[auto-download] Detected image %s (%s) in response, downloading...", id, name)
+			
+			// Retry download up to 10 times because the image might still be generating/saving on OpenAI backend
+			var data []byte
+			var err error
+			for attempt := 1; attempt <= 10; attempt++ {
+				data, err = downloadChatGPTFile(id)
+				if err == nil {
+					break
+				}
+				log.Printf("[auto-download] Image %s not ready yet, retrying in 2 seconds... (attempt %d/10)", id, attempt)
+				time.Sleep(2 * time.Second)
+			}
+
+			if err == nil {
+				_ = os.MkdirAll("output", 0755)
+				localPath := "output/" + name + ".png"
+				err = os.WriteFile(localPath, data, 0644)
+				if err != nil {
+					log.Printf("[auto-download] Error saving file %s: %v", localPath, err)
+				} else {
+					log.Printf("[auto-download] Successfully saved image to %s", localPath)
+				}
+			} else {
+				log.Printf("[auto-download] Error downloading image %s: %v", id, err)
+			}
+		}
+	}
+
+	shouldPoll := newConvID != "" && (strings.Contains(response, "Processing image") ||
+		strings.Contains(response, "creating images") ||
+		strings.Contains(response, "generating your image") ||
+		len(attachments) > 0 ||
+		isPromptForImage(prompt))
+
+	if shouldPoll {
+		log.Printf("[chat] detected async image generation/edit in conversation %s, starting poll...", newConvID)
+		var excludeIDs []string
+		for _, att := range attachments {
+			excludeIDs = append(excludeIDs, att.ID)
+		}
+		polledResponse, pollErr := pollForImage(prompt, newConvID, 150*time.Second, excludeIDs...)
+		if pollErr == nil {
+			return polledResponse, newConvID, nil
+		}
+		log.Printf("[chat] image poll failed: %v, returning original response", pollErr)
+	}
+	return response, newConvID, nil
+}
+
+func isPromptForImage(prompt string) bool {
+	p := strings.ToLower(prompt)
+	keywords := []string{
+		"generate", "create", "draw", "make", "edit", "add", "remove",
+		"change", "modify", "paint", "cartoon", "3d", "render",
+		"picture", "photo", "illustration", "dall-e", "dalle",
+	}
+	for _, kw := range keywords {
+		if strings.Contains(p, kw) {
+			return true
+		}
+	}
+	return false
+}

chatgpt-free-api/chatgpt.go

@@ -0,0 +1,1009 @@
+package main
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// FileAttachment represents an uploaded file to attach to a conversation
+type FileAttachment struct {
+	ID       string `json:"id"`
+	Name     string `json:"name"`
+	Size     int64  `json:"size"`
+	MimeType string `json:"mime_type"`
+	Width    int    `json:"width,omitempty"`
+	Height   int    `json:"height,omitempty"`
+}
+
+var (
+	fileIDToPromptMu sync.RWMutex
+	fileIDToPrompt   = make(map[string]string)
+)
+
+func registerFilePrompt(fileID, prompt string) {
+	fileIDToPromptMu.Lock()
+	fileIDToPrompt[fileID] = prompt
+	fileIDToPromptMu.Unlock()
+}
+
+func getFilePrompt(fileID string) string {
+	fileIDToPromptMu.RLock()
+	defer fileIDToPromptMu.RUnlock()
+	return fileIDToPrompt[fileID]
+}
+
+// ─── Browser-context API proxy ──────────────────────────────
+
+type apiCallParams struct {
+	URL          string
+	Method       string
+	Headers      map[string]string
+	Body         any
+	ResponseType string
+}
+
+type apiCallResult struct {
+	OK             bool              `json:"ok"`
+	Status         int               `json:"status"`
+	Headers        map[string]string `json:"headers"`
+	Body           string            `json:"body"`
+	ConversationID string            `json:"conversation_id,omitempty"`
+	FinalURL       string            `json:"finalUrl"`
+	Error          string            `json:"error"`
+	IsBase64       bool              `json:"isBase64,omitempty"`
+	RawText        string            `json:"rawText,omitempty"`
+}
+
+func callChatGPTAPI(p apiCallParams, timeout time.Duration) (*apiCallResult, error) {
+	if !waitForExtension(cfg.ExtensionWait()) {
+		return nil, fmt.Errorf("extension not connected")
+	}
+	extMu.Lock()
+	conn := extConn
+	extMu.Unlock()
+	if conn == nil {
+		return nil, fmt.Errorf("extension not connected")
+	}
+
+	id := uuid.NewString()
+	ch := make(chan WSMessage, 1)
+	pendingMu.Lock()
+	pending[id] = ch
+	pendingMu.Unlock()
+	defer func() {
+		pendingMu.Lock()
+		delete(pending, id)
+		pendingMu.Unlock()
+	}()
+
+	// Route internal methods directly
+	wsMethod := "api_request"
+	if strings.HasPrefix(p.URL, "__internal__/") {
+		switch {
+		case strings.Contains(p.URL, "solve_pow"):
+			wsMethod = "solve_pow"
+		case strings.Contains(p.URL, "solve_turnstile"):
+			wsMethod = "solve_turnstile"
+		}
+	}
+
+	msg := WSMessage{
+		ID:     id,
+		Method: wsMethod,
+		Params: map[string]any{
+			"url":          p.URL,
+			"method":       p.Method,
+			"headers":      p.Headers,
+			"body":         p.Body,
+			"responseType": p.ResponseType,
+		},
+	}
+
+	extMu.Lock()
+	err := conn.WriteJSON(msg)
+	extMu.Unlock()
+	if err != nil {
+		return nil, err
+	}
+
+	select {
+	case resp := <-ch:
+		if resp.Error != "" {
+			return nil, fmt.Errorf("%s", resp.Error)
+		}
+		raw, _ := json.Marshal(resp.Result)
+		var r apiCallResult
+		if err := json.Unmarshal(raw, &r); err != nil {
+			return nil, fmt.Errorf("decode api result: %w", err)
+		}
+		return &r, nil
+	case <-time.After(cfg.ChatTimeout()):
+		return nil, fmt.Errorf("timeout waiting for extension api_request")
+	}
+}
+
+// ─── ChatGPT internal API client ─────────────────────────────
+
+type chatGPTRequirements struct {
+	Token       string `json:"token"`
+	Proofofwork struct {
+		Required   bool   `json:"required"`
+		Seed       string `json:"seed"`
+		Difficulty string `json:"difficulty"`
+	} `json:"proofofwork"`
+	Turnstile struct {
+		Required bool `json:"required"`
+	} `json:"turnstile"`
+}
+
+func getSessionToken() (string, error) {
+	r, err := callChatGPTAPI(apiCallParams{
+		URL:    "https://chatgpt.com/api/auth/session",
+		Method: "GET",
+	}, cfg.APITimeout())
+	if err != nil {
+		return "", err
+	}
+	if r.Status != 200 {
+		return "", fmt.Errorf("session http %d: %s", r.Status, snippet(r.Body, 200))
+	}
+	var s struct {
+		AccessToken string `json:"accessToken"`
+	}
+	if err := json.Unmarshal([]byte(r.Body), &s); err != nil {
+		return "", fmt.Errorf("session decode: %w", err)
+	}
+	if s.AccessToken == "" {
+		return "", fmt.Errorf("no access token (not logged in to chatgpt.com?)")
+	}
+	return s.AccessToken, nil
+}
+
+func getChatRequirements(token string) (*chatGPTRequirements, error) {
+	r, err := callChatGPTAPI(apiCallParams{
+		URL:    "https://chatgpt.com/backend-api/sentinel/chat-requirements",
+		Method: "POST",
+		Headers: map[string]string{
+			"Authorization": "Bearer " + token,
+		},
+		Body: map[string]any{"p": ""},
+	}, cfg.APITimeout())
+	if err != nil {
+		return nil, err
+	}
+	if r.Status != 200 {
+		return nil, fmt.Errorf("requirements http %d: %s", r.Status, snippet(r.Body, 200))
+	}
+	var cr chatGPTRequirements
+	if err := json.Unmarshal([]byte(r.Body), &cr); err != nil {
+		return nil, fmt.Errorf("requirements decode: %w", err)
+	}
+	return &cr, nil
+}
+
+func solveTurnstile() (string, error) {
+	// Delegate to extension — it executes in chatgpt.com tab where turnstile widget exists
+	r, err := callChatGPTAPI(apiCallParams{
+		URL:    "__internal__/solve_turnstile",
+		Method: "POST",
+	}, cfg.APITimeout())
+	if err != nil {
+		return "", err
+	}
+	if r.Error != "" {
+		return "", fmt.Errorf("%s", r.Error)
+	}
+	var result struct {
+		Token string `json:"token"`
+	}
+	if err := json.Unmarshal([]byte(r.Body), &result); err != nil {
+		return strings.TrimSpace(r.Body), nil
+	}
+	return result.Token, nil
+}
+
+func solveProofOfWork(seed, difficulty string) (string, error) {
+	// Delegate PoW to extension which runs it in browser JS context
+	r, err := callChatGPTAPI(apiCallParams{
+		URL:    "__internal__/solve_pow",
+		Method: "POST",
+		Body:   map[string]any{"seed": seed, "difficulty": difficulty},
+	}, cfg.ChatTimeout())
+	if err != nil {
+		return "", fmt.Errorf("pow solve: %w", err)
+	}
+	if r.Error != "" {
+		return "", fmt.Errorf("pow solve error: %s", r.Error)
+	}
+	var result struct {
+		Token string `json:"token"`
+	}
+	if err := json.Unmarshal([]byte(r.Body), &result); err != nil {
+		// Body itself might be the token
+		return strings.TrimSpace(r.Body), nil
+	}
+	if result.Token != "" {
+		return result.Token, nil
+	}
+	return strings.TrimSpace(r.Body), nil
+}
+
+// sendChatViaFullConversation uses extension's full_conversation method.
+// This does EVERYTHING inside the browser tab context (session, requirements, PoW, turnstile, conversation)
+// which avoids 403 issues because all tokens are generated natively.
+func sendChatViaFullConversation(prompt, conversationID, model, thinkingEffort string, attachments ...FileAttachment) (string, string, string, error) {
+	log.Println("[chat-full] sending full conversation via extension...")
+	if !waitForExtension(cfg.ExtensionWait()) {
+		return "", "", "", fmt.Errorf("extension not connected")
+	}
+	extMu.Lock()
+	conn := extConn
+	extMu.Unlock()
+	if conn == nil {
+		return "", "", "", fmt.Errorf("extension not connected")
+	}
+
+	id := uuid.NewString()
+	ch := make(chan WSMessage, 1)
+	pendingMu.Lock()
+	pending[id] = ch
+	pendingMu.Unlock()
+	defer func() {
+		pendingMu.Lock()
+		delete(pending, id)
+		pendingMu.Unlock()
+	}()
+
+	params := map[string]any{
+		"prompt":          prompt,
+		"model":           model,
+		"conversation_id": conversationID,
+		"thinking_effort": thinkingEffort,
+	}
+	if len(attachments) > 0 {
+		params["attachments"] = attachments
+	}
+
+	msg := WSMessage{
+		ID:     id,
+		Method: "full_conversation",
+		Params: params,
+	}
+
+	extMu.Lock()
+	err := conn.WriteJSON(msg)
+	extMu.Unlock()
+	if err != nil {
+		return "", "", "", err
+	}
+
+	select {
+	case resp := <-ch:
+		if resp.Error != "" {
+			return "", "", "", fmt.Errorf("%s", resp.Error)
+		}
+		raw, _ := json.Marshal(resp.Result)
+		var r apiCallResult
+		if err := json.Unmarshal(raw, &r); err != nil {
+			return "", "", "", fmt.Errorf("decode result: %w", err)
+		}
+		if r.Body == "" {
+			return "", "", "", fmt.Errorf("empty response from full_conversation")
+		}
+		log.Printf("[chat-full] got response (%d chars), conversation_id: %s", len(r.Body), r.ConversationID)
+		return r.Body, r.RawText, r.ConversationID, nil
+	case <-time.After(cfg.ChatTimeout()):
+		return "", "", "", fmt.Errorf("timeout waiting for full_conversation")
+	}
+}
+
+func sendChatViaAPI(prompt string) (string, error) {
+	log.Println("[chat] getting session token...")
+	token, err := getSessionToken()
+	if err != nil {
+		return "", fmt.Errorf("session: %w", err)
+	}
+	log.Println("[chat] getting chat requirements...")
+	cr, err := getChatRequirements(token)
+	if err != nil {
+		return "", fmt.Errorf("requirements: %w", err)
+	}
+
+	headers := map[string]string{
+		"Authorization": "Bearer " + token,
+		"openai-sentinel-chat-requirements-token": cr.Token,
+		"Accept": "text/event-stream",
+	}
+
+	if cr.Proofofwork.Required {
+		log.Printf("[chat] solving proof-of-work (seed=%s, diff=%s)", cr.Proofofwork.Seed, cr.Proofofwork.Difficulty)
+		powToken, err := solveProofOfWork(cr.Proofofwork.Seed, cr.Proofofwork.Difficulty)
+		if err != nil {
+			return "", fmt.Errorf("proof-of-work: %w", err)
+		}
+		headers["openai-sentinel-proof-token"] = powToken
+	}
+	if cr.Turnstile.Required {
+		log.Println("[chat] solving turnstile...")
+		tsToken, err := solveTurnstile()
+		if err != nil {
+			log.Printf("[chat] turnstile failed: %v, attempting without it", err)
+		} else if tsToken != "" {
+			headers["openai-sentinel-turnstile-token"] = tsToken
+		}
+	}
+
+	msgID := uuid.NewString()
+	parentID := uuid.NewString()
+	body := map[string]any{
+		"action": "next",
+		"messages": []any{
+			map[string]any{
+				"id":          msgID,
+				"author":      map[string]any{"role": "user"},
+				"content":     map[string]any{"content_type": "text", "parts": []string{prompt}},
+				"metadata":    map[string]any{},
+				"create_time": float64(time.Now().Unix()),
+			},
+		},
+		"parent_message_id":             parentID,
+		"model":                         cfg.DefaultModel,
+		"timezone_offset_min":           cfg.TimezoneOffsetMin,
+		"history_and_training_disabled": false,
+		"force_paragen":                 false,
+		"force_rate_limit":              false,
+		"websocket_request_id":          uuid.NewString(),
+		"conversation_mode":             map[string]any{"kind": "primary_assistant"},
+		"suggestions":                   []any{},
+	}
+
+	log.Println("[chat] sending conversation request...")
+	r, err := callChatGPTAPI(apiCallParams{
+		URL:     "https://chatgpt.com/backend-api/conversation",
+		Method:  "POST",
+		Headers: headers,
+		Body:    body,
+	}, cfg.ChatTimeout())
+	if err != nil {
+		return "", err
+	}
+	if r.Status != 200 {
+		return "", fmt.Errorf("conversation http %d: %s", r.Status, snippet(r.Body, 400))
+	}
+	out := parseSSEFinal(r.Body)
+	if out == "" {
+		return "", fmt.Errorf("empty assistant response (raw len=%d): %s", len(r.Body), snippet(r.Body, 200))
+	}
+	log.Printf("[chat] got response (%d chars)", len(out))
+	return out, nil
+}
+
+func parseSSEFinal(raw string) string {
+	var snapshot string
+	var delta strings.Builder
+	fileIDs := make(map[string]bool)
+	var currentContentType string
+
+	var processDelta func(ev map[string]any)
+	processDelta = func(ev map[string]any) {
+		vVal, hasV := ev["v"]
+		if !hasV {
+			return
+		}
+		path, hasPath := ev["p"].(string)
+		op, _ := ev["o"].(string)
+
+		if hasPath && strings.Contains(path, "/message/content/parts/0") {
+			if op == "replace" {
+				if s, ok := vVal.(string); ok {
+					delta.Reset()
+					delta.WriteString(s)
+				}
+			} else if op == "" || op == "append" {
+				if s, ok := vVal.(string); ok {
+					delta.WriteString(s)
+				}
+			}
+		} else if !hasPath {
+			if currentContentType == "text" || currentContentType == "multimodal_text" || currentContentType == "" {
+				if s, ok := vVal.(string); ok {
+					delta.WriteString(s)
+				}
+			}
+		} else if op == "patch" {
+			if subList, ok := vVal.([]any); ok {
+				for _, subVal := range subList {
+					if subMap, ok := subVal.(map[string]any); ok {
+						processDelta(subMap)
+					}
+				}
+			}
+		}
+	}
+
+	for _, line := range strings.Split(raw, "\n") {
+		line = strings.TrimSpace(line)
+		if !strings.HasPrefix(line, "data:") {
+			continue
+		}
+		payload := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
+		if payload == "" || payload == "[DONE]" {
+			continue
+		}
+		var ev map[string]any
+		if err := json.Unmarshal([]byte(payload), &ev); err != nil {
+			continue
+		}
+		if vVal, ok := ev["v"].(map[string]any); ok {
+			if msgObj, ok := vVal["message"].(map[string]any); ok {
+				if contentObj, ok := msgObj["content"].(map[string]any); ok {
+					if ct, ok := contentObj["content_type"].(string); ok {
+						currentContentType = ct
+					}
+				}
+			}
+		} else if msgObj, ok := ev["message"].(map[string]any); ok {
+			if contentObj, ok := msgObj["content"].(map[string]any); ok {
+				if ct, ok := contentObj["content_type"].(string); ok {
+					currentContentType = ct
+				}
+			}
+		}
+		if s := extractParts0(ev, fileIDs); s != "" {
+			snapshot = s
+		}
+		if v, ok := ev["v"]; ok {
+			if vm, ok := v.(map[string]any); ok {
+				if s := extractParts0(vm, fileIDs); s != "" {
+					snapshot = s
+				}
+			}
+		}
+		processDelta(ev)
+	}
+	out := snapshot
+	deltaStr := delta.String()
+	if delta.Len() > 0 {
+		isJSONBlock := strings.HasPrefix(deltaStr, `{"`) || strings.HasPrefix(deltaStr, `":"`)
+		if !isJSONBlock {
+			if delta.Len() > len(snapshot) {
+				out = deltaStr
+			} else if !strings.Contains(out, deltaStr) {
+				out += deltaStr
+			}
+		}
+	}
+	if len(fileIDs) > 0 {
+		var imageMarkdown strings.Builder
+		imageMarkdown.WriteString("\n\n")
+		for fileID := range fileIDs {
+			imageMarkdown.WriteString(fmt.Sprintf("![Generated Image](http://%s/api/download?file_id=%s)\n", cfg.ListenAddr, fileID))
+		}
+		out += imageMarkdown.String()
+	}
+	return out;
+}
+
+func extractParts0(ev map[string]any, fileIDs map[string]bool) string {
+	msg, ok := ev["message"].(map[string]any)
+	if !ok {
+		return ""
+	}
+	content, ok := msg["content"].(map[string]any)
+	if !ok {
+		return ""
+	}
+	parts, ok := content["parts"].([]any)
+	if !ok || len(parts) == 0 {
+		return ""
+	}
+	for _, part := range parts {
+		if partMap, ok := part.(map[string]any); ok {
+			if partMap["content_type"] == "image_asset_pointer" {
+				if assetPtr, ok := partMap["asset_pointer"].(string); ok {
+					if strings.HasPrefix(assetPtr, "file-service://") {
+						fID := strings.TrimPrefix(assetPtr, "file-service://")
+						fileIDs[fID] = true
+					} else if strings.HasPrefix(assetPtr, "sediment://") {
+						fID := strings.TrimPrefix(assetPtr, "sediment://")
+						fileIDs[fID] = true
+					}
+				}
+			}
+		}
+	}
+	s, _ := parts[0].(string)
+	return s
+}
+
+func snippet(s string, n int) string {
+	s = strings.ReplaceAll(s, "\n", " ")
+	if len(s) > n {
+		s = s[:n] + "..."
+	}
+	return s
+}
+
+// downloadChatGPTFile fetches the signed download URL from chatgpt.com backend API,
+// requests it via the browser bridge (forcing base64 response), and decodes it back to raw bytes.
+func downloadChatGPTFile(fileID string) ([]byte, error) {
+	log.Printf("[download] requesting download url for file %s...", fileID)
+	token, err := getSessionToken()
+	if err != nil {
+		return nil, fmt.Errorf("session token: %w", err)
+	}
+
+	downloadURL := fmt.Sprintf("https://chatgpt.com/backend-api/files/%s/download", fileID)
+	r, err := callChatGPTAPI(apiCallParams{
+		URL:    downloadURL,
+		Method: "GET",
+		Headers: map[string]string{
+			"Authorization": "Bearer " + token,
+		},
+	}, cfg.APITimeout())
+	if err != nil {
+		return nil, fmt.Errorf("file download api call: %w", err)
+	}
+	if r.Status != 200 {
+		return nil, fmt.Errorf("file download http %d: %s", r.Status, snippet(r.Body, 200))
+	}
+
+	var dlInfo struct {
+		Status      string `json:"status"`
+		DownloadURL string `json:"download_url"`
+	}
+	if err := json.Unmarshal([]byte(r.Body), &dlInfo); err != nil {
+		return nil, fmt.Errorf("decode file download info: %w", err)
+	}
+	if dlInfo.DownloadURL == "" {
+		return nil, fmt.Errorf("empty download url returned: %s", r.Body)
+	}
+
+	log.Printf("[download] downloading binary from signed url: %s", snippet(dlInfo.DownloadURL, 100))
+	rBin, err := callChatGPTAPI(apiCallParams{
+		URL:          dlInfo.DownloadURL,
+		Method:       "GET",
+		ResponseType: "base64",
+	}, cfg.ChatTimeout())
+	if err != nil {
+		return nil, fmt.Errorf("fetch binary: %w", err)
+	}
+	if rBin.Status != 200 {
+		return nil, fmt.Errorf("fetch binary http %d: %s", rBin.Status, snippet(rBin.Body, 200))
+	}
+
+	if rBin.IsBase64 {
+		data, err := base64.StdEncoding.DecodeString(rBin.Body)
+		if err != nil {
+			return nil, fmt.Errorf("decode base64 response: %w", err)
+		}
+		return data, nil
+	}
+
+	return []byte(rBin.Body), nil
+}
+
+type conversationResponse struct {
+	CurrentNode string `json:"current_node"`
+	Mapping     map[string]struct {
+		Message *struct {
+			ID     string `json:"id"`
+			Author struct {
+				Role string `json:"role"`
+			} `json:"author"`
+			Status string `json:"status"`
+			Content *struct {
+				ContentType string `json:"content_type"`
+				Parts       []any  `json:"parts"`
+			} `json:"content"`
+		} `json:"message"`
+	} `json:"mapping"`
+}
+
+func extractImageFileIDs(data []byte) []string {
+	var resp conversationResponse
+	var ids []string
+	if err := json.Unmarshal(data, &resp); err != nil {
+		return nil
+	}
+	for _, node := range resp.Mapping {
+		if node.Message == nil || node.Message.Content == nil {
+			continue
+		}
+		if node.Message.Content.ContentType == "multimodal_text" {
+			for _, part := range node.Message.Content.Parts {
+				if partMap, ok := part.(map[string]any); ok {
+					if partMap["content_type"] == "image_asset_pointer" {
+						if assetPtr, ok := partMap["asset_pointer"].(string); ok {
+							var id string
+							if strings.HasPrefix(assetPtr, "file-service://") {
+								id = strings.TrimPrefix(assetPtr, "file-service://")
+							} else if strings.HasPrefix(assetPtr, "sediment://") {
+								id = strings.TrimPrefix(assetPtr, "sediment://")
+							}
+							if id != "" {
+								ids = append(ids, id)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if len(ids) == 0 {
+		var regex = regexp.MustCompile(`(file_[0-9a-fA-F]{32}|file-[a-zA-Z0-9_-]{24,36})`)
+		matches := regex.FindAllString(string(data), -1)
+		seen := make(map[string]bool)
+		for _, m := range matches {
+			if !seen[m] {
+				seen[m] = true
+				ids = append(ids, m)
+			}
+		}
+	}
+	return ids
+}
+
+var sanitizeRegexp = regexp.MustCompile(`[^a-zA-Z0-9\s-_]`)
+var spaceRegexp = regexp.MustCompile(`\s+`)
+
+func getPromptFilename(prompt, fileID string) string {
+	// 1. Lowercase
+	s := strings.ToLower(prompt)
+	
+	// 2. Remove common command/generation prefixes
+	prefixes := []string{
+		"generate an image:",
+		"generate a image:",
+		"generate image:",
+		"create an image:",
+		"create a image:",
+		"create image:",
+		"draw an image:",
+		"draw a image:",
+		"draw image:",
+		"make an image:",
+		"make a image:",
+		"make image:",
+		"generate a drawing of",
+		"generate an image of",
+		"generate drawing of",
+		"generate image of",
+		"generate a",
+		"generate an",
+		"generate",
+		"create an image of",
+		"create a drawing of",
+		"create image of",
+		"create drawing of",
+		"create a",
+		"create",
+		"draw a",
+		"draw",
+	}
+	for _, prefix := range prefixes {
+		if strings.HasPrefix(s, prefix) {
+			s = strings.TrimPrefix(s, prefix)
+			break
+		}
+	}
+	s = strings.TrimSpace(s)
+
+	// 2b. Strip leading articles (a, an, the) for cleaner names
+	articles := []string{"a ", "an ", "the "}
+	for _, art := range articles {
+		if strings.HasPrefix(s, art) {
+			s = strings.TrimPrefix(s, art)
+			break
+		}
+	}
+	s = strings.TrimSpace(s)
+
+	// 3. Remove non-alphanumeric characters
+	s = sanitizeRegexp.ReplaceAllString(s, "")
+
+	// 4. Replace spaces with underscores
+	s = spaceRegexp.ReplaceAllString(s, "_")
+
+	// 5. Keep only first 3 words for a clean short name
+	parts := strings.SplitN(s, "_", 4)
+	if len(parts) > 3 {
+		parts = parts[:3]
+	}
+	s = strings.Join(parts, "_")
+
+	if s == "" {
+		s = "image"
+	}
+
+	// 6. Append short file suffix for uniqueness (last 8 characters of ID)
+	suffix := fileID
+	if len(suffix) > 8 {
+		suffix = suffix[len(suffix)-8:]
+	}
+
+	return fmt.Sprintf("%s_%s", s, suffix)
+}
+
+func pollForImage(prompt, conversationID string, timeout time.Duration, excludeIDs ...string) (string, error) {
+	deadline := time.Now().Add(timeout)
+	
+	excludeMap := make(map[string]bool)
+	for _, id := range excludeIDs {
+		excludeMap[id] = true
+	}
+	
+	// Track all generated image IDs we've found and processed
+	foundImages := make(map[string]bool)
+	var generatedIDs []string
+
+	for time.Now().Before(deadline) {
+		token, err := getSessionToken()
+		if err != nil {
+			time.Sleep(1 * time.Second)
+			continue
+		}
+		res, err := callChatGPTAPI(apiCallParams{
+			URL:    "https://chatgpt.com/backend-api/conversation/" + conversationID,
+			Method: "GET",
+			Headers: map[string]string{
+				"Authorization": "Bearer " + token,
+			},
+		}, cfg.APITimeout())
+		if err != nil {
+			log.Printf("[poll] ❌ callChatGPTAPI failed: %v", err)
+			time.Sleep(1 * time.Second)
+			continue
+		}
+		log.Printf("[poll] Polled conversation %s, status=%d, bodyLen=%d", conversationID, res.Status, len(res.Body))
+		if res.Status == 200 {
+			_ = os.WriteFile("debug_poll.json", []byte(res.Body), 0644)
+			
+			var pollResp conversationResponse
+			if err := json.Unmarshal([]byte(res.Body), &pollResp); err == nil {
+				ids := extractImageFileIDs([]byte(res.Body))
+				
+				// Find any new generated image IDs we haven't seen yet
+				var newIDs []string
+				for _, id := range ids {
+					if !excludeMap[id] && !foundImages[id] {
+						foundImages[id] = true
+						newIDs = append(newIDs, id)
+						generatedIDs = append(generatedIDs, id)
+					}
+				}
+
+				// Download any new images immediately
+				for _, id := range newIDs {
+					registerFilePrompt(id, prompt)
+					name := getPromptFilename(prompt, id)
+					log.Printf("[auto-download] Auto-downloading generated image %s (%s)...", id, name)
+					
+					var data []byte
+					var dlErr error
+					// Try to download with retries (in case the file metadata is created but binary isn't fully ready yet on OpenAI backend)
+					for attempt := 1; attempt <= 5; attempt++ {
+						data, dlErr = downloadChatGPTFile(id)
+						if dlErr == nil {
+							break
+						}
+						time.Sleep(1 * time.Second)
+					}
+					if dlErr == nil {
+						_ = os.MkdirAll("output", 0755)
+						localPath := "output/" + name + ".png"
+						dlErr = os.WriteFile(localPath, data, 0644)
+						if dlErr != nil {
+							log.Printf("[auto-download] Error saving file %s locally: %v", localPath, dlErr)
+						} else {
+							log.Printf("[auto-download] Successfully saved image to %s", localPath)
+						}
+					} else {
+						log.Printf("[auto-download] Error downloading image %s: %v", id, dlErr)
+					}
+				}
+
+				// Break early if we found new generated images
+				if len(generatedIDs) > 0 {
+					log.Printf("[poll] Found generated images: %v. Stopping poll.", generatedIDs)
+					break
+				}
+
+				// Check if the conversation leaf is finished and not generating
+				if leaf, exists := pollResp.Mapping[pollResp.CurrentNode]; exists && leaf.Message != nil {
+					role := leaf.Message.Author.Role
+					status := leaf.Message.Status
+					
+					isFinishedAssistant := role == "assistant" && status == "finished_successfully"
+					isFinishedToolWithImage := role == "tool" && status == "finished_successfully" &&
+						leaf.Message.Content != nil && hasImagePointer(leaf.Message.Content.Parts)
+
+					if isFinishedAssistant || isFinishedToolWithImage {
+						log.Printf("[poll] Conversation leaf is finished (%s, %s). Stopping poll.", role, status)
+						break
+					}
+				}
+			}
+		}
+		time.Sleep(1500 * time.Millisecond)
+	}
+
+	// Compile and return the markdown response for all generated images
+	if len(generatedIDs) > 0 {
+		var markdown strings.Builder
+		markdown.WriteString("Here is your generated image:\n\n")
+		for _, id := range generatedIDs {
+			markdown.WriteString(fmt.Sprintf("![Generated Image](http://127.0.0.1:9225/api/download?file_id=%s&prompt=%s)\n", id, url.QueryEscape(prompt)))
+		}
+		return markdown.String(), nil
+	}
+
+	return "", fmt.Errorf("timeout waiting for image generation in conversation %s", conversationID)
+}
+
+func hasImagePointer(parts []any) bool {
+	for _, part := range parts {
+		if partMap, ok := part.(map[string]any); ok {
+			if partMap["content_type"] == "image_asset_pointer" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// uploadFileToChatGPT uploads a local file to ChatGPT via the backend API and returns a FileAttachment.
+// It uses the extension's api_request method to call /backend-api/files with proper auth.
+func uploadFileToChatGPT(filePath string) (*FileAttachment, error) {
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("read file: %w", err)
+	}
+
+	fileName := filepath.Base(filePath)
+	mimeType := "image/png"
+	ext := strings.ToLower(filepath.Ext(fileName))
+	switch ext {
+	case ".jpg", ".jpeg":
+		mimeType = "image/jpeg"
+	case ".webp":
+		mimeType = "image/webp"
+	case ".gif":
+		mimeType = "image/gif"
+	}
+
+	fileSize := int64(len(data))
+
+	log.Printf("[upload] Uploading file %s (%d bytes, %s) to ChatGPT...", fileName, fileSize, mimeType)
+
+	// Step 1: Create file upload via backend API
+	token, err := getSessionToken()
+	if err != nil {
+		return nil, fmt.Errorf("get session token: %w", err)
+	}
+
+	createBody := map[string]any{
+		"file_name":  fileName,
+		"file_size":  fileSize,
+		"use_case":   "multimodal",
+	}
+	bodyJSON, _ := json.Marshal(createBody)
+	res, err := callChatGPTAPI(apiCallParams{
+		URL:    "https://chatgpt.com/backend-api/files",
+		Method: "POST",
+		Headers: map[string]string{
+			"Authorization": "Bearer " + token,
+			"Content-Type":  "application/json",
+		},
+		Body: string(bodyJSON),
+	}, cfg.APITimeout())
+	if err != nil {
+		return nil, fmt.Errorf("create file: %w", err)
+	}
+	if res.Status != 200 {
+		return nil, fmt.Errorf("create file status %d: %s", res.Status, res.Body[:min(len(res.Body), 500)])
+	}
+
+	var createResp struct {
+		FileID    string `json:"file_id"`
+		UploadURL string `json:"upload_url"`
+		Status    string `json:"status"`
+	}
+	if err := json.Unmarshal([]byte(res.Body), &createResp); err != nil {
+		return nil, fmt.Errorf("parse create response: %w", err)
+	}
+
+	log.Printf("[upload] File created with ID: %s, upload URL: %s", createResp.FileID, createResp.UploadURL[:min(len(createResp.UploadURL), 80)])
+
+	// Step 2: Upload file data to the upload URL via extension (browser context for proper auth)
+	b64Data := base64.StdEncoding.EncodeToString(data)
+	uploadRes, err := callChatGPTAPI(apiCallParams{
+		URL:    createResp.UploadURL,
+		Method: "PUT",
+		Headers: map[string]string{
+			"Content-Type":   mimeType,
+			"X-Ms-Blob-Type": "BlockBlob",
+			"X-Ms-Version":   "2020-04-08",
+		},
+		Body: b64Data,
+	}, cfg.APITimeout())
+	if err != nil {
+		return nil, fmt.Errorf("upload file data: %w", err)
+	}
+	if uploadRes.Status >= 300 {
+		return nil, fmt.Errorf("upload file data status %d: %s", uploadRes.Status, uploadRes.Body[:min(len(uploadRes.Body), 200)])
+	}
+
+	log.Printf("[upload] File data uploaded successfully, marking as uploaded...")
+
+	// Step 3: Mark file as uploaded
+	markBody := map[string]any{}
+	markJSON, _ := json.Marshal(markBody)
+	markRes, err := callChatGPTAPI(apiCallParams{
+		URL:    fmt.Sprintf("https://chatgpt.com/backend-api/files/%s/uploaded", createResp.FileID),
+		Method: "POST",
+		Headers: map[string]string{
+			"Authorization": "Bearer " + token,
+			"Content-Type":  "application/json",
+		},
+		Body: string(markJSON),
+	}, cfg.APITimeout())
+	if err != nil {
+		log.Printf("[upload] Warning: mark uploaded failed: %v", err)
+	} else {
+		log.Printf("[upload] Mark uploaded response: status=%d", markRes.Status)
+	}
+
+	// Step 4: Wait for processing
+	for i := 0; i < 10; i++ {
+		time.Sleep(1 * time.Second)
+		checkRes, err := callChatGPTAPI(apiCallParams{
+			URL:    fmt.Sprintf("https://chatgpt.com/backend-api/files/%s", createResp.FileID),
+			Method: "GET",
+			Headers: map[string]string{
+				"Authorization": "Bearer " + token,
+			},
+		}, cfg.APITimeout())
+		if err != nil {
+			continue
+		}
+		var fileStatus struct {
+			Status string `json:"status"`
+			FileID string `json:"file_id"`
+		}
+		if err := json.Unmarshal([]byte(checkRes.Body), &fileStatus); err == nil {
+			log.Printf("[upload] File %s status: %s", createResp.FileID, fileStatus.Status)
+			if fileStatus.Status == "success" || fileStatus.Status == "ready" {
+				break
+			}
+		}
+	}
+
+	log.Printf("[upload] File upload complete: %s (%s)", createResp.FileID, fileName)
+
+	return &FileAttachment{
+		ID:       createResp.FileID,
+		Name:     fileName,
+		Size:     fileSize,
+		MimeType: mimeType,
+	}, nil
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+

chatgpt-free-api/config.go

@@ -0,0 +1,102 @@
+package main
+
+import (
+	"encoding/json"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+// AppConfig holds all configurable values for the agent.
+type AppConfig struct {
+	ListenAddr               string `json:"listen_addr"`
+	DefaultModel             string `json:"default_model"`
+	DefaultThinkingEffort    string `json:"default_thinking_effort"`
+	TimeoutSeconds           int    `json:"timeout_seconds"`
+	ExtensionWaitSeconds     int    `json:"extension_wait_seconds"`
+	ChatTimeoutSeconds       int    `json:"chat_timeout_seconds"`
+	APITimeoutSeconds        int    `json:"api_timeout_seconds"`
+	MaxSniffs                int    `json:"max_sniffs"`
+	BulkDelaySeconds         int    `json:"bulk_delay_seconds"`
+	BrowserWakeCooldownSecs  int    `json:"browser_wake_cooldown_seconds"`
+	TimezoneOffsetMin        int    `json:"timezone_offset_min"`
+	RawSSEOutputPath         string `json:"raw_sse_output_path"`
+}
+
+// Convenience duration helpers
+func (c *AppConfig) Timeout() time.Duration {
+	return time.Duration(c.TimeoutSeconds) * time.Second
+}
+
+func (c *AppConfig) ExtensionWait() time.Duration {
+	return time.Duration(c.ExtensionWaitSeconds) * time.Second
+}
+
+func (c *AppConfig) ChatTimeout() time.Duration {
+	return time.Duration(c.ChatTimeoutSeconds) * time.Second
+}
+
+func (c *AppConfig) APITimeout() time.Duration {
+	return time.Duration(c.APITimeoutSeconds) * time.Second
+}
+
+func (c *AppConfig) BrowserWakeCooldown() time.Duration {
+	return time.Duration(c.BrowserWakeCooldownSecs) * time.Second
+}
+
+// cfg is the global config instance used throughout the app.
+var cfg = defaultConfig()
+
+func defaultConfig() AppConfig {
+	return AppConfig{
+		ListenAddr:              "127.0.0.1:9224",
+		DefaultModel:            "auto",
+		DefaultThinkingEffort:   "",
+		TimeoutSeconds:          300,
+		ExtensionWaitSeconds:    10,
+		ChatTimeoutSeconds:      240,
+		APITimeoutSeconds:       30,
+		MaxSniffs:               250,
+		BulkDelaySeconds:        2,
+		BrowserWakeCooldownSecs: 60,
+		TimezoneOffsetMin:       -330,
+		RawSSEOutputPath:        "",
+	}
+}
+
+// loadConfig reads config.json from the same directory as the executable.
+// If the file doesn't exist, defaults are used silently.
+func loadConfig() {
+	// Try config.json next to the binary first, then in CWD
+	paths := []string{}
+
+	if exe, err := os.Executable(); err == nil {
+		paths = append(paths, filepath.Join(filepath.Dir(exe), "config.json"))
+	}
+	paths = append(paths, "config.json")
+
+	var data []byte
+	var loadedPath string
+	for _, p := range paths {
+		d, err := os.ReadFile(p)
+		if err == nil {
+			data = d
+			loadedPath = p
+			break
+		}
+	}
+
+	if data == nil {
+		log.Println("[config] No config.json found, using defaults")
+		return
+	}
+
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		log.Printf("[config] Error parsing %s: %v — using defaults", loadedPath, err)
+		cfg = defaultConfig()
+		return
+	}
+
+	log.Printf("[config] Loaded from %s", loadedPath)
+}

chatgpt-free-api/config.json

@@ -0,0 +1,14 @@
+{
+  "listen_addr": "127.0.0.1:9225",
+  "default_model": "gpt-5-5",
+  "default_thinking_effort": "",
+  "timeout_seconds": 300,
+  "extension_wait_seconds": 10,
+  "chat_timeout_seconds": 240,
+  "api_timeout_seconds": 30,
+  "max_sniffs": 250,
+  "bulk_delay_seconds": 2,
+  "browser_wake_cooldown_seconds": 60,
+  "timezone_offset_min": -330,
+  "raw_sse_output_path": "/Users/akashyadav/.gemini/antigravity-ide/scratch/raw_sse.txt"
+}

chatgpt-free-api/cookies.go

@@ -0,0 +1,477 @@
+package main
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// CookieObject represents a browser cookie from the extension
+type CookieObject struct {
+	Domain         string  `json:"domain"`
+	ExpirationDate float64 `json:"expirationDate,omitempty"`
+	HostOnly       bool    `json:"hostOnly,omitempty"`
+	HttpOnly       bool    `json:"httpOnly,omitempty"`
+	Name           string  `json:"name"`
+	Path           string  `json:"path"`
+	SameSite       string  `json:"sameSite,omitempty"`
+	Secure         bool    `json:"secure,omitempty"`
+	Session        bool    `json:"session,omitempty"`
+	StoreId        string  `json:"storeId,omitempty"`
+	Value          string  `json:"value"`
+}
+
+type CookiePayloadMessage struct {
+	Type    string         `json:"type"`
+	Cookies []CookieObject `json:"cookies"`
+}
+
+const CookiesFile = "cookies.json"
+
+var (
+	cachedCookies   []CookieObject
+	cachedCookiesMu sync.RWMutex
+	lastCookieSync  time.Time
+)
+
+// GetCachedCookieHeader returns a cookie header string for HTTP requests to chatgpt.com
+func GetCachedCookieHeader() string {
+	cachedCookiesMu.RLock()
+	defer cachedCookiesMu.RUnlock()
+	var parts []string
+	for _, ck := range cachedCookies {
+		parts = append(parts, fmt.Sprintf("%s=%s", ck.Name, ck.Value))
+	}
+	return strings.Join(parts, "; ")
+}
+
+// GetCookieValue returns the value of a specific cookie by name
+func GetCookieValue(name string) string {
+	cachedCookiesMu.RLock()
+	defer cachedCookiesMu.RUnlock()
+	for _, ck := range cachedCookies {
+		if ck.Name == name {
+			return ck.Value
+		}
+	}
+	return ""
+}
+
+// HasCookies returns true if we have synced cookies
+func HasCookies() bool {
+	cachedCookiesMu.RLock()
+	defer cachedCookiesMu.RUnlock()
+	return len(cachedCookies) > 0
+}
+
+// GetLastCookieSync returns the time of the last cookie sync
+func GetLastCookieSync() time.Time {
+	cachedCookiesMu.RLock()
+	defer cachedCookiesMu.RUnlock()
+	return lastCookieSync
+}
+
+// LoadCookiesFromFile loads cookies from cookies.json at startup
+func LoadCookiesFromFile() {
+	data, err := os.ReadFile(CookiesFile)
+	if err != nil {
+		log.Printf("[cookies] No existing cookies.json found: %v", err)
+		return
+	}
+	var cookies []CookieObject
+	if err := json.Unmarshal(data, &cookies); err != nil {
+		log.Printf("[cookies] Error parsing cookies.json: %v", err)
+		return
+	}
+	cachedCookiesMu.Lock()
+	cachedCookies = cookies
+	lastCookieSync = time.Now()
+	cachedCookiesMu.Unlock()
+	log.Printf("[cookies] Loaded %d cookies from disk", len(cookies))
+}
+
+// HandleCookiePayload processes cookies received from the extension
+func HandleCookiePayload(cookies []CookieObject) {
+	log.Printf("🍪 Received %d cookies from extension", len(cookies))
+
+	// Save to cookies.json
+	data, err := json.MarshalIndent(cookies, "", "  ")
+	if err != nil {
+		log.Printf("❌ Failed to marshal cookies: %v", err)
+		return
+	}
+
+	if err := os.WriteFile(CookiesFile, data, 0644); err != nil {
+		log.Printf("❌ Failed to save cookies.json: %v", err)
+		return
+	}
+
+	// Update in-memory cache
+	cachedCookiesMu.Lock()
+	cachedCookies = cookies
+	lastCookieSync = time.Now()
+	cachedCookiesMu.Unlock()
+
+	log.Printf("🍪 Cached %d cookies for direct API calls", len(cookies))
+}
+
+// ─── Direct HTTP client using cookies ───────────────────────────
+
+// DirectHTTPResponse holds the response from a direct HTTP request
+type DirectHTTPResponse struct {
+	Status  int               `json:"status"`
+	Body    string            `json:"body"`
+	Headers map[string]string `json:"headers"`
+}
+
+// DirectHTTPRequest makes an HTTP request to chatgpt.com using synced cookies
+func DirectHTTPRequest(method, urlStr string, headers map[string]string, body string) (*DirectHTTPResponse, error) {
+	if !HasCookies() {
+		return nil, fmt.Errorf("no cookies available — extension has not synced yet")
+	}
+
+	var bodyReader io.Reader
+	if body != "" {
+		bodyReader = strings.NewReader(body)
+	}
+
+	req, err := http.NewRequest(method, urlStr, bodyReader)
+	if err != nil {
+		return nil, fmt.Errorf("create request: %w", err)
+	}
+
+	// Set cookies
+	req.Header.Set("Cookie", GetCachedCookieHeader())
+
+	// Set default headers for ChatGPT
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36")
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
+	req.Header.Set("Origin", "https://chatgpt.com")
+	req.Header.Set("Referer", "https://chatgpt.com/")
+	req.Header.Set("Sec-Fetch-Dest", "empty")
+	req.Header.Set("Sec-Fetch-Mode", "cors")
+	req.Header.Set("Sec-Fetch-Site", "same-origin")
+	req.Header.Set("sec-ch-ua", `"Not(A:Brand";v="8", "Chromium";v="146", "Google Chrome";v="146"`)
+	req.Header.Set("sec-ch-ua-mobile", "?0")
+	req.Header.Set("sec-ch-ua-platform", `"macOS"`)
+
+	// Set oai-did from cookies
+	oaiDid := GetCookieValue("oai-did")
+	if oaiDid != "" {
+		req.Header.Set("OAI-Device-Id", oaiDid)
+	}
+	req.Header.Set("OAI-Language", "en-US")
+
+	// Override with custom headers
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
+
+	client := &http.Client{
+		Timeout: 120 * time.Second,
+	}
+
+	log.Printf("[direct-http] Requesting %s %s...", method, urlStr)
+	resp, err := client.Do(req)
+	if err != nil {
+		log.Printf("[direct-http] ❌ Connection error: %v", err)
+		return nil, fmt.Errorf("http request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Printf("[direct-http] ❌ Read response error: %v", err)
+		return nil, fmt.Errorf("read response: %w", err)
+	}
+
+	log.Printf("[direct-http] Response status: %d (body length: %d bytes)", resp.StatusCode, len(respBody))
+
+	respHeaders := make(map[string]string)
+	for k, v := range resp.Header {
+		if len(v) > 0 {
+			respHeaders[k] = v[0]
+		}
+	}
+
+	return &DirectHTTPResponse{
+		Status:  resp.StatusCode,
+		Body:    string(respBody),
+		Headers: respHeaders,
+	}, nil
+}
+
+// ─── Direct ChatGPT API Functions ───────────────────────────────
+
+// GetSessionTokenDirect gets the session token directly using cookies (no extension needed)
+func GetSessionTokenDirect() (string, error) {
+	resp, err := DirectHTTPRequest("GET", "https://chatgpt.com/api/auth/session", nil, "")
+	if err != nil {
+		return "", fmt.Errorf("session request: %w", err)
+	}
+	if resp.Status != 200 {
+		return "", fmt.Errorf("session http %d: %s", resp.Status, snippet(resp.Body, 200))
+	}
+	var s struct {
+		AccessToken string `json:"accessToken"`
+	}
+	if err := json.Unmarshal([]byte(resp.Body), &s); err != nil {
+		return "", fmt.Errorf("session decode: %w", err)
+	}
+	if s.AccessToken == "" {
+		return "", fmt.Errorf("no access token (not logged in)")
+	}
+	return s.AccessToken, nil
+}
+
+// GetChatRequirementsDirect gets chat requirements directly using cookies
+func GetChatRequirementsDirect(token string) (*chatGPTRequirements, error) {
+	resp, err := DirectHTTPRequest("POST", "https://chatgpt.com/backend-api/sentinel/chat-requirements",
+		map[string]string{
+			"Authorization": "Bearer " + token,
+			"Content-Type":  "application/json",
+		},
+		`{"p":""}`,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if resp.Status != 200 {
+		return nil, fmt.Errorf("requirements http %d: %s", resp.Status, snippet(resp.Body, 200))
+	}
+	var cr chatGPTRequirements
+	if err := json.Unmarshal([]byte(resp.Body), &cr); err != nil {
+		return nil, fmt.Errorf("requirements decode: %w", err)
+	}
+	return &cr, nil
+}
+
+// SendChatDirect sends a conversation request directly to ChatGPT using cookies (no extension needed)
+// Returns: response text, rawSSE, conversation_id, error
+func SendChatDirect(prompt, conversationID, model, thinkingEffort string) (string, string, string, error) {
+	if !HasCookies() {
+		return "", "", "", fmt.Errorf("no cookies — extension has not synced")
+	}
+
+	log.Println("[direct] Getting session token...")
+	token, err := GetSessionTokenDirect()
+	if err != nil {
+		log.Printf("[direct] ❌ Session token fetch failed: %v", err)
+		return "", "", "", fmt.Errorf("session: %w", err)
+	}
+
+	log.Println("[direct] Getting chat requirements...")
+	cr, err := GetChatRequirementsDirect(token)
+	if err != nil {
+		log.Printf("[direct] ❌ Chat requirements fetch failed: %v", err)
+		return "", "", "", fmt.Errorf("requirements: %w", err)
+	}
+
+	headers := map[string]string{
+		"Authorization":                           "Bearer " + token,
+		"Content-Type":                            "application/json",
+		"Accept":                                  "text/event-stream",
+		"openai-sentinel-chat-requirements-token": cr.Token,
+	}
+
+	// PoW solving
+	if cr.Proofofwork.Required {
+		log.Printf("[direct] Solving proof-of-work (seed=%s, diff=%s)", cr.Proofofwork.Seed, cr.Proofofwork.Difficulty)
+		powToken := SolveFNVPow(cr.Proofofwork.Seed, cr.Proofofwork.Difficulty)
+		if powToken != "" {
+			headers["openai-sentinel-proof-token"] = powToken
+		} else {
+			log.Println("[direct] PoW solve failed, proceeding without it")
+		}
+	}
+
+	// Turnstile — can't solve from Go, skip
+	if cr.Turnstile.Required {
+		log.Println("[direct] ⚠️ Turnstile required — cannot solve from Go, falling back to extension")
+		return "", "", "", fmt.Errorf("TURNSTILE_REQUIRED")
+	}
+
+	// Resolve parent message ID
+	parentID := "client-created-root"
+	if conversationID != "" {
+		convResp, err := DirectHTTPRequest("GET",
+			"https://chatgpt.com/backend-api/conversation/"+conversationID,
+			map[string]string{"Authorization": "Bearer " + token},
+			"",
+		)
+		if err == nil && convResp.Status == 200 {
+			var convData struct {
+				CurrentNode string `json:"current_node"`
+			}
+			if json.Unmarshal([]byte(convResp.Body), &convData) == nil && convData.CurrentNode != "" {
+				parentID = convData.CurrentNode
+			}
+		}
+	}
+
+	// Build conversation body
+	actualModel := model
+	var resolvedThinkingEffort string
+	if thinkingEffort != "" {
+		resolvedThinkingEffort = thinkingEffort
+	}
+	if strings.Contains(model, "thinking") {
+		if strings.Contains(model, "-extended") {
+			resolvedThinkingEffort = "extended"
+			actualModel = strings.Replace(model, "-extended", "", 1)
+		} else if strings.Contains(model, "-standard") {
+			resolvedThinkingEffort = "standard"
+			actualModel = strings.Replace(model, "-standard", "", 1)
+		} else if resolvedThinkingEffort == "" {
+			resolvedThinkingEffort = "standard"
+		}
+	}
+
+	convBody := map[string]any{
+		"action": "next",
+		"messages": []any{
+			map[string]any{
+				"id":     uuid.NewString(),
+				"author": map[string]any{"role": "user"},
+				"content": map[string]any{
+					"content_type": "text",
+					"parts":        []string{prompt},
+				},
+				"metadata":    map[string]any{},
+				"create_time": float64(time.Now().Unix()),
+			},
+		},
+		"parent_message_id":                     parentID,
+		"model":                                 actualModel,
+		"timezone_offset_min":                   cfg.TimezoneOffsetMin,
+		"timezone":                              "Asia/Kolkata",
+		"history_and_training_disabled":          false,
+		"fork_from_shared_post":                 false,
+		"force_paragen":                         false,
+		"force_rate_limit":                      false,
+		"conversation_mode":                     map[string]any{"kind": "primary_assistant"},
+		"enable_message_followups":              true,
+		"system_hints":                          []any{},
+		"supports_buffering":                    true,
+		"supported_encodings":                   []string{"v1"},
+		"paragen_cot_summary_display_override":  "allow",
+		"force_parallel_switch":                 "auto",
+		"websocket_request_id":                  uuid.NewString(),
+		"client_contextual_info": map[string]any{
+			"is_dark_mode":      false,
+			"time_since_loaded": 0,
+			"page_height":       800,
+			"page_width":        1200,
+			"pixel_ratio":       1,
+			"screen_height":     1080,
+			"screen_width":      1920,
+		},
+	}
+	if conversationID != "" {
+		convBody["conversation_id"] = conversationID
+	}
+	if resolvedThinkingEffort != "" {
+		convBody["thinking_effort"] = resolvedThinkingEffort
+	}
+
+	bodyJSON, _ := json.Marshal(convBody)
+
+	log.Println("[direct] Sending conversation request...")
+	resp, err := DirectHTTPRequest("POST", "https://chatgpt.com/backend-api/conversation", headers, string(bodyJSON))
+	if err != nil {
+		log.Printf("[direct] ❌ Conversation request failed: %v", err)
+		return "", "", "", fmt.Errorf("conversation request: %w", err)
+	}
+	if resp.Status != 200 {
+		log.Printf("[direct] ❌ Conversation HTTP %d: %s", resp.Status, snippet(resp.Body, 400))
+		return "", "", "", fmt.Errorf("conversation http %d: %s", resp.Status, snippet(resp.Body, 400))
+	}
+
+	// Parse SSE response
+	text := parseSSEFinal(resp.Body)
+	if text == "" {
+		return "", resp.Body, "", fmt.Errorf("empty assistant response (raw len=%d)", len(resp.Body))
+	}
+
+	// Extract conversation_id from SSE
+	newConvID := extractConversationID(resp.Body)
+
+	// Save raw SSE if configured
+	if cfg.RawSSEOutputPath != "" {
+		_ = os.WriteFile(cfg.RawSSEOutputPath, []byte(resp.Body), 0644)
+	}
+
+	log.Printf("[direct] Got response (%d chars), conversation_id: %s", len(text), newConvID)
+	return text, resp.Body, newConvID, nil
+}
+
+// extractConversationID pulls conversation_id from SSE stream
+func extractConversationID(raw string) string {
+	for _, line := range strings.Split(raw, "\n") {
+		line = strings.TrimSpace(line)
+		if !strings.HasPrefix(line, "data:") {
+			continue
+		}
+		payload := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
+		if payload == "" || payload == "[DONE]" {
+			continue
+		}
+		var ev map[string]any
+		if err := json.Unmarshal([]byte(payload), &ev); err != nil {
+			continue
+		}
+		if cid, ok := ev["conversation_id"].(string); ok && cid != "" {
+			return cid
+		}
+		if v, ok := ev["v"].(map[string]any); ok {
+			if cid, ok := v["conversation_id"].(string); ok && cid != "" {
+				return cid
+			}
+		}
+	}
+	return ""
+}
+
+// ─── FNV PoW Solver ─────────────────────────────────────────────
+
+// SolveFNVPow solves ChatGPT's FNV-based proof of work natively in Go
+func SolveFNVPow(seed, difficulty string) string {
+	for nonce := 0; nonce < 500000; nonce++ {
+		// Build a config array matching the browser's format
+		config := fmt.Sprintf(`[3000,"%s",4294705152,%d,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",null,"","en-US","en-US",%d,"hardwareConcurrency−8","location","self",0,"%s","",8,%d]`,
+			time.Now().String(), nonce, nonce, uuid.NewString(), time.Now().UnixMilli())
+
+		encoded := base64.StdEncoding.EncodeToString([]byte(config))
+		input := seed + encoded
+
+		hash := fnvHash(input)
+		if len(hash) >= len(difficulty) && hash[:len(difficulty)] <= difficulty {
+			return "gAAAAAB" + encoded + "~S"
+		}
+	}
+	return ""
+}
+
+func fnvHash(input string) string {
+	h := uint32(2166136261)
+	for i := 0; i < len(input); i++ {
+		h ^= uint32(input[i])
+		h *= 16777619
+	}
+	h ^= h >> 16
+	h *= 2246822507
+	h ^= h >> 13
+	h *= 3266489909
+	h ^= h >> 16
+	return fmt.Sprintf("%08x", h)
+}

chatgpt-free-api/cookies_test.go

@@ -0,0 +1,104 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestCookiesLifecycle(t *testing.T) {
+	// 1. Prepare dummy cookies
+	dummyCookies := []CookieObject{
+		{
+			Domain: ".chatgpt.com",
+			Name:   "oai-did",
+			Value:  "test-device-id-123",
+		},
+		{
+			Domain: ".chatgpt.com",
+			Name:   "__Secure-next-auth.session-token",
+			Value:  "test-session-token-abc",
+		},
+	}
+
+	// 2. Write dummy cookies to test file path (temporarily override CookiesFile or use the function)
+	// Since CookiesFile is a constant ("cookies.json"), we should back up existing cookies.json if it exists,
+	// write our dummy data, run the test, and restore it.
+	const testFile = "cookies.json"
+	var backupData []byte
+	backupExists := false
+
+	if _, err := os.Stat(testFile); err == nil {
+		backupData, err = os.ReadFile(testFile)
+		if err == nil {
+			backupExists = true
+		}
+	}
+
+	// Clean up after test
+	defer func() {
+		if backupExists {
+			_ = os.WriteFile(testFile, backupData, 0644)
+		} else {
+			_ = os.Remove(testFile)
+		}
+	}()
+
+	// Write test cookies
+	data, err := json.Marshal(dummyCookies)
+	if err != nil {
+		t.Fatalf("Failed to marshal dummy cookies: %v", err)
+	}
+	if err := os.WriteFile(testFile, data, 0644); err != nil {
+		t.Fatalf("Failed to write test cookies.json: %v", err)
+	}
+
+	// 3. Test LoadCookiesFromFile
+	LoadCookiesFromFile()
+
+	if !HasCookies() {
+		t.Errorf("Expected HasCookies() to be true, got false")
+	}
+
+	// 4. Test GetCookieValue
+	oaiDid := GetCookieValue("oai-did")
+	if oaiDid != "test-device-id-123" {
+		t.Errorf("Expected oai-did to be 'test-device-id-123', got '%s'", oaiDid)
+	}
+
+	// 5. Test GetCachedCookieHeader
+	header := GetCachedCookieHeader()
+	if !strings.Contains(header, "oai-did=test-device-id-123") {
+		t.Errorf("Expected header to contain 'oai-did=test-device-id-123', got '%s'", header)
+	}
+	if !strings.Contains(header, "__Secure-next-auth.session-token=test-session-token-abc") {
+		t.Errorf("Expected header to contain session token, got '%s'", header)
+	}
+
+	// 6. Test HandleCookiePayload directly
+	newDummyCookies := []CookieObject{
+		{
+			Domain: ".chatgpt.com",
+			Name:   "oai-did",
+			Value:  "updated-device-id",
+		},
+	}
+	HandleCookiePayload(newDummyCookies)
+	
+	updatedOaiDid := GetCookieValue("oai-did")
+	if updatedOaiDid != "updated-device-id" {
+		t.Errorf("Expected updated oai-did to be 'updated-device-id', got '%s'", updatedOaiDid)
+	}
+}
+
+func TestSolveFNVPow(t *testing.T) {
+	// Verify that the solver functions and can find a solution for a very easy difficulty
+	// Or at least it doesn't crash.
+	// Difficulty is a hex string prefix. Let's pass a very high/easy difficulty threshold
+	// to make sure it finishes quickly. "ffff" means any hash <= "ffff" (which is almost all of them since it's 8 hex chars max).
+	// Let's use "9" as difficulty which is easy enough to solve in a few nonces.
+	token := SolveFNVPow("0.abcdef123456", "9")
+	t.Logf("Solved PoW token: %s", token)
+	// It should either solve it or exit. Let's make sure it doesn't crash.
+}

chatgpt-free-api/extension.go

@@ -0,0 +1,161 @@
+package main
+
+import (
+	"encoding/json"
+	"log"
+	"os"
+	"os/exec"
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+type WSMessage struct {
+	Type   string         `json:"type,omitempty"`
+	Method string         `json:"method,omitempty"`
+	ID     string         `json:"id,omitempty"`
+	Params map[string]any `json:"params,omitempty"`
+	Result any            `json:"result,omitempty"`
+	Error  string         `json:"error,omitempty"`
+}
+
+var (
+	extConn           *websocket.Conn
+	extMu             sync.Mutex
+	reloadTriggered   bool
+	pendingMu         sync.Mutex
+	pending           = map[string]chan WSMessage{}
+	extInfo           map[string]any
+	lastBrowserOpenMu sync.Mutex
+	lastBrowserOpen   time.Time
+)
+
+func isExtensionConnected() bool {
+	extMu.Lock()
+	defer extMu.Unlock()
+	return extConn != nil
+}
+
+func getExtensionInfo() map[string]any {
+	extMu.Lock()
+	defer extMu.Unlock()
+	if extInfo == nil {
+		return nil
+	}
+	out := map[string]any{}
+	for k, v := range extInfo {
+		out[k] = v
+	}
+	return out
+}
+
+func openBrowser(url string) error {
+	var cmd *exec.Cmd
+	switch runtime.GOOS {
+	case "windows":
+		cmd = exec.Command("cmd", "/c", "start", url)
+	case "darwin":
+		cmd = exec.Command("open", url)
+	default: // "linux", "freebsd", etc.
+		cmd = exec.Command("xdg-open", url)
+	}
+	return cmd.Start()
+}
+
+func wakeUpExtension() {
+	log.Println("[agent] Extension not connected. Waiting for background connection...")
+}
+
+func waitForExtension(timeout time.Duration) bool {
+	if isExtensionConnected() {
+		return true
+	}
+	wakeUpExtension()
+
+	deadline := time.Now().Add(timeout)
+	for time.Now().Before(deadline) {
+		if isExtensionConnected() {
+			return true
+		}
+		time.Sleep(250 * time.Millisecond)
+	}
+	return false
+}
+
+func handleExtensionMessage(msg WSMessage) {
+	if msg.Result != nil {
+		if m, ok := msg.Result.(map[string]any); ok {
+			if raw, ok := m["rawText"].(string); ok {
+				if cfg.RawSSEOutputPath == "" {
+					return
+				}
+				err := os.WriteFile(cfg.RawSSEOutputPath, []byte(raw), 0644)
+				if err != nil {
+					log.Printf("ERROR WRITING RAW SSE: %v", err)
+				}
+			}
+		}
+	}
+
+	if msg.ID == "" {
+		if msg.Type == "extension_ready" {
+			extMu.Lock()
+			extInfo = msg.Params
+			extMu.Unlock()
+			log.Printf("[ws] extension ready: %v", msg.Params)
+			return
+		}
+		if msg.Type == "cookies_payload" {
+			// Extract cookies from params
+			if cookiesRaw, ok := msg.Params["cookies"]; ok {
+				raw, _ := json.Marshal(cookiesRaw)
+				var cookies []CookieObject
+				if err := json.Unmarshal(raw, &cookies); err == nil && len(cookies) > 0 {
+					HandleCookiePayload(cookies)
+				} else {
+					log.Printf("[ws] Failed to parse cookies_payload: %v", err)
+				}
+			}
+			return
+		}
+		if msg.Type == "sniffed_chat_request" {
+			sniff := sniffFromMessage(msg)
+			addSniff(sniff)
+			log.Printf("🔍 SNIFFED[%s/%s]: %s %s status=%d", sniff.Source, sniff.Phase, sniff.Method, sniff.URL, sniff.Status)
+			if len(sniff.Headers) > 0 {
+				log.Printf("   Headers:")
+				for k, v := range sniff.Headers {
+					log.Printf("     %s: %v", k, v)
+				}
+			}
+			if sniff.Payload != "" {
+				log.Printf("   Payload: %s", sniff.Payload)
+			}
+			if sniff.Response != "" {
+				log.Printf("   Response: %s", sniff.Response)
+			}
+			if sniff.Error != "" {
+				log.Printf("   Error: %s", sniff.Error)
+			}
+		}
+		return
+	}
+
+	pendingMu.Lock()
+	ch := pending[msg.ID]
+	pendingMu.Unlock()
+	if ch != nil {
+		if msg.Error != "" {
+			log.Printf("[ws] response id=%s error=%s", msg.ID[:8], msg.Error)
+		} else {
+			log.Printf("[ws] response id=%s ok", msg.ID[:8])
+		}
+		ch <- msg
+		return
+	}
+
+	b, _ := json.MarshalIndent(msg, "", "  ")
+	log.Printf("[ws] unmatched message: %s", b)
+}

chatgpt-free-api/go.mod

@@ -0,0 +1,8 @@
+module chatgpt-agent
+
+go 1.26
+
+require (
+	github.com/google/uuid v1.6.0
+	github.com/gorilla/websocket v1.5.3
+)

chatgpt-free-api/go.sum

@@ -0,0 +1,4 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=

chatgpt-free-api/gpt-extension/background.js

@@ -0,0 +1,1030 @@
+/**
+ * GPT Agent Sync — Background Service Worker
+ * Auto-syncs ChatGPT cookies to Go backend and handles background API/PoW fallbacks.
+ */
+
+const AGENT_WS_URL = 'ws://127.0.0.1:9225';
+const CHATGPT_URL = 'https://chatgpt.com/';
+const CHATGPT_TAB_URLS = ['https://chatgpt.com/*', 'https://chat.openai.com/*'];
+
+let ws = null;
+let lastCookieSyncTime = null;
+let hasCookieSynced = false;
+let cookieSyncDebounceTimeout = null;
+let isRefreshingSession = false;
+let extensionState = 'off';
+
+// ChatGPT cookies to sync
+const CHATGPT_COOKIE_DOMAINS = ['.chatgpt.com', 'chatgpt.com', '.chat.openai.com', 'chat.openai.com'];
+const CHATGPT_COOKIE_NAMES = new Set([
+  '__Secure-next-auth.session-token',
+  '__Host-next-auth.csrf-token',
+  '__Secure-next-auth.callback-url',
+  'oai-did',
+  '_puid',
+  '__cf_bm',
+  'cf_clearance',
+  '_cfuvid',
+  'oai-sc',
+  'oai-hlib',
+  '__cflb',
+  'intercom-id-dgkjq2bp',
+  'intercom-device-id-dgkjq2bp',
+  'intercom-session-dgkjq2bp',
+]);
+
+// Initialize alarms
+chrome.runtime.onInstalled.addListener(init);
+chrome.runtime.onStartup.addListener(init);
+
+chrome.alarms.onAlarm.addListener(async (alarm) => {
+  if (alarm.name === 'reconnect') connectToBackend();
+  if (alarm.name === 'keepAlive') keepAlive();
+  if (alarm.name === 'sessionKeepAlive') {
+    console.log('[ChatGPT Sync] Running periodic session keep-alive refresh...');
+    ensureChatGPTTabAndSync(true);
+  }
+});
+
+async function init() {
+  connectToBackend();
+  // Keep-alive ping every 24 seconds (no cookies payload)
+  chrome.alarms.create('keepAlive', { periodInMinutes: 0.4 });
+  // Proactively refresh ChatGPT session tab every 15 minutes to rotate cookies
+  chrome.alarms.create('sessionKeepAlive', { periodInMinutes: 15 });
+  
+  const data = await chrome.storage.local.get(['lastCookieSyncTime']);
+  if (data.lastCookieSyncTime) lastCookieSyncTime = data.lastCookieSyncTime;
+  setState('off');
+}
+
+// Badge and State Management
+function setState(newState) {
+  extensionState = newState;
+  const badges = { idle: '●', running: '▶', off: '○' };
+  const colors = { idle: '#10b981', running: '#f59e0b', off: '#ef4444' };
+  
+  chrome.action.setBadgeText({ text: badges[extensionState] || '' });
+  chrome.action.setBadgeBackgroundColor({ color: colors[extensionState] || '#000' });
+  
+  // Notify popup if it's open
+  chrome.runtime.sendMessage({ type: 'COOKIE_SYNC_UPDATE' }).catch(() => {});
+}
+
+// WebSocket Connection Management
+function connectToBackend() {
+  if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) {
+    return;
+  }
+
+  console.log('[ChatGPT Sync] Connecting to local backend at:', AGENT_WS_URL);
+  hasCookieSynced = false;
+  setState('off');
+
+  try {
+    ws = new WebSocket(AGENT_WS_URL);
+  } catch (e) {
+    console.error('[ChatGPT Sync] WS Connection Error:', e);
+    scheduleReconnect();
+    return;
+  }
+
+  ws.onopen = () => {
+    console.log('[ChatGPT Sync] Connected to Go Backend!');
+    chrome.alarms.clear('reconnect');
+    setState('idle');
+    performCookieSync();
+  };
+
+  ws.onmessage = async (event) => {
+    try {
+      const msg = JSON.parse(event.data);
+      if (msg.method === 'api_request') {
+        await handleApiRequest(msg);
+      } else if (msg.method === 'full_conversation') {
+        await handleFullConversation(msg);
+      } else if (msg.method === 'open_chatgpt') {
+        chrome.tabs.create({ url: CHATGPT_URL });
+      } else if (msg.method === 'solve_pow') {
+        await handleSolvePow(msg);
+      } else if (msg.method === 'solve_turnstile') {
+        await handleSolveTurnstile(msg);
+      } else if (msg.method === 'trigger_sync') {
+        console.log('[ChatGPT Sync] Backend requested fresh cookies. Activating session refresh...');
+        ensureChatGPTTabAndSync(false);
+      } else if (msg.method === 'reload_extension') {
+        chrome.runtime.reload();
+      }
+    } catch (e) {
+      console.error('[ChatGPT Sync] Error handling message:', e);
+    }
+  };
+
+  ws.onclose = () => {
+    console.log('[ChatGPT Sync] Connection closed. Reconnecting...');
+    setState('off');
+    scheduleReconnect();
+  };
+
+  ws.onerror = (err) => {
+    console.error('[ChatGPT Sync] WebSocket Error:', err);
+    setState('off');
+  };
+}
+
+function scheduleReconnect() {
+  chrome.alarms.create('reconnect', { delayInMinutes: 0.083 }); // ~5s
+}
+
+function keepAlive() {
+  if (ws?.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: 'ping' }));
+  } else {
+    connectToBackend();
+  }
+}
+
+function sendToAgent(msg) {
+  if (ws?.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(msg));
+  }
+}
+
+// Cookie Sync Logic
+function performCookieSync() {
+  if (!ws || ws.readyState !== WebSocket.OPEN) return;
+
+  chrome.cookies.getAll({}, (cookies) => {
+    const chatgptCookies = cookies.filter(c => {
+      return CHATGPT_COOKIE_DOMAINS.some(d => c.domain === d || c.domain.endsWith(d));
+    });
+
+    const formatted = chatgptCookies.map(c => {
+      let exp = c.expirationDate;
+      if (!exp || c.session) {
+        exp = Math.floor(Date.now() / 1000) + 31536000; // Default 1 year
+      }
+      let sameSite = c.sameSite || 'unspecified';
+      if (sameSite === 'no_restriction') sameSite = 'none';
+
+      return {
+        domain: c.domain,
+        expirationDate: exp,
+        hostOnly: c.hostOnly,
+        httpOnly: c.httpOnly,
+        name: c.name,
+        path: c.path,
+        sameSite: sameSite,
+        secure: c.secure,
+        session: c.session,
+        storeId: c.storeId || '0',
+        value: c.value
+      };
+    });
+
+    console.log(`[ChatGPT Sync] Syncing ${formatted.length} cookies to backend`);
+    ws.send(JSON.stringify({
+      type: 'cookies_payload',
+      params: {
+        cookies: formatted
+      }
+    }));
+
+    hasCookieSynced = true;
+    lastCookieSyncTime = Date.now();
+    chrome.storage.local.set({ lastCookieSyncTime });
+    setState('idle');
+  });
+}
+
+// Proactive refresh mechanism: opens or reloads ChatGPT tab to rotate cookies
+async function ensureChatGPTTabAndSync(quietMode = false) {
+  if (isRefreshingSession) return;
+  isRefreshingSession = true;
+  setState('running');
+
+  try {
+    const tabs = await chrome.tabs.query({ url: CHATGPT_TAB_URLS });
+    if (tabs.length > 0) {
+      console.log('[ChatGPT Sync] ChatGPT tab exists. Reloading to rotate cookies...');
+      await chrome.tabs.reload(tabs[0].id);
+    } else {
+      console.log('[ChatGPT Sync] No ChatGPT tab found. Launching background session...');
+      await chrome.tabs.create({ url: CHATGPT_URL, active: false });
+    }
+
+    setTimeout(() => { 
+      if (isRefreshingSession) {
+        isRefreshingSession = false; 
+        setState(ws && ws.readyState === WebSocket.OPEN ? 'idle' : 'off');
+      }
+    }, 15000);
+  } catch (e) {
+    console.error('[ChatGPT Sync] Session refresh error:', e);
+    isRefreshingSession = false;
+    setState(ws && ws.readyState === WebSocket.OPEN ? 'idle' : 'off');
+    performCookieSync();
+  }
+}
+
+// Tab updates to trigger cookie sync on complete load
+chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
+  const isGptTab = tab.url && CHATGPT_TAB_URLS.some(pattern => {
+    const regex = new RegExp(pattern.replace(/\./g, '\\.').replace(/\*/g, '.*'));
+    return regex.test(tab.url);
+  });
+  if (changeInfo.status === 'complete' && isGptTab) {
+    console.log('[ChatGPT Sync] ChatGPT tab loaded completely. Performing cookie sync...');
+    performCookieSync();
+    isRefreshingSession = false;
+    setState('idle');
+  }
+});
+
+// Real-Time Cookie Changed Listener
+chrome.cookies.onChanged.addListener((changeInfo) => {
+  const cookie = changeInfo.cookie;
+  const isTarget = CHATGPT_COOKIE_DOMAINS.some(d => cookie.domain === d || cookie.domain.endsWith(d));
+
+  if (isTarget && CHATGPT_COOKIE_NAMES.has(cookie.name)) {
+    if (changeInfo.removed) return;
+    
+    console.log(`[ChatGPT Sync] Real-time cookie updated: ${cookie.name}. Scheduling sync...`);
+    if (cookieSyncDebounceTimeout) clearTimeout(cookieSyncDebounceTimeout);
+    cookieSyncDebounceTimeout = setTimeout(() => {
+      console.log('[ChatGPT Sync] Running debounced real-time cookie sync...');
+      performCookieSync();
+    }, 1500);
+  }
+});
+
+// Communication with Popup
+chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
+  if (msg.type === 'GET_STATUS') {
+    sendResponse({
+      connected: ws && ws.readyState === WebSocket.OPEN,
+      lastSyncTime: lastCookieSyncTime,
+      hasSyncedOnce: hasCookieSynced,
+      state: extensionState
+    });
+  }
+  if (msg.type === 'FORCE_SYNC') {
+    ensureChatGPTTabAndSync(false);
+    sendResponse({ ok: true });
+  }
+  return true;
+});
+
+// Metadata Helpers
+async function getOaiDeviceId() {
+  try {
+    const cookie = await chrome.cookies.get({ url: 'https://chatgpt.com', name: 'oai-did' });
+    return cookie ? cookie.value : '';
+  } catch (e) {
+    return '';
+  }
+}
+
+let cachedBuildNumber = null;
+let cachedBuildId = null;
+let lastCacheTime = 0;
+
+async function getClientMetadata() {
+  const now = Date.now();
+  if (cachedBuildNumber && cachedBuildId && (now - lastCacheTime < 3600000)) {
+    return { buildNumber: cachedBuildNumber, buildId: cachedBuildId };
+  }
+  try {
+    const resp = await fetch('https://chatgpt.com/', { credentials: 'omit' });
+    if (resp.ok) {
+      const text = await resp.text();
+      const buildNumberMatch = text.match(/meta name="build-number" content="([^"]+)"/);
+      const buildIdMatch = text.match(/"buildId":"([^"]+)"/);
+      if (buildNumberMatch) cachedBuildNumber = buildNumberMatch[1];
+      if (buildIdMatch) cachedBuildId = buildIdMatch[1];
+      lastCacheTime = now;
+    }
+  } catch (e) {
+    console.error('[ChatGPT Sync] Metadata fetch error:', e);
+  }
+  return {
+    buildNumber: cachedBuildNumber || 'main-build-latest',
+    buildId: cachedBuildId || 'latest'
+  };
+}
+
+async function getNativeHeaders() {
+  const headers = {};
+  const oaiDid = await getOaiDeviceId();
+  if (oaiDid) headers['OAI-Device-Id'] = oaiDid;
+  headers['OAI-Language'] = self.navigator.language || 'en-US';
+  
+  const meta = await getClientMetadata();
+  if (meta.buildNumber) headers['OAI-Client-Build-Number'] = meta.buildNumber;
+  if (meta.buildId) headers['OAI-Client-Version'] = meta.buildId;
+  return headers;
+}
+
+// Background API request handlers
+async function handleApiRequest(msg) {
+  const id = msg.id || `api-${Date.now()}`;
+  const params = msg.params || {};
+  const { url, method = 'GET', headers = {}, body = null, returnHeaders = true, responseType = null } = params;
+
+  // Allow internal methods
+  if (url && url.startsWith('__internal__')) {
+    if (url.includes('solve_pow')) {
+      await handleSolvePow(msg);
+      return;
+    }
+    if (url.includes('solve_turnstile')) {
+      await handleSolveTurnstile(msg);
+      return;
+    }
+    sendToAgent({ id, error: 'UNKNOWN_INTERNAL_METHOD' });
+    return;
+  }
+
+  if (!url || !/^https:\/\/(chatgpt\.com|chat\.openai\.com|[a-z0-9]+\.oaiusercontent\.com)\//.test(url)) {
+    sendToAgent({ id, error: 'INVALID_URL: ' + (url || 'empty') });
+    return;
+  }
+
+  setState('running');
+
+  try {
+    const tab = await getChatGPTTab();
+    await waitForTabReady(tab.id);
+    const [exec] = await chrome.scripting.executeScript({
+      target: { tabId: tab.id },
+      world: 'MAIN',
+      args: [{ url, method, headers, body, returnHeaders, responseType }],
+      func: async ({ url, method, headers, body, returnHeaders, responseType }) => {
+        try {
+          // Build headers — merge provided headers with native OAI headers
+          const nativeHeaders = {};
+          // Get OAI device ID from cookie
+          const cookies = document.cookie.split(';').map(c => c.trim());
+          const oaiDid = cookies.find(c => c.startsWith('oai-did='));
+          if (oaiDid) nativeHeaders['OAI-Device-Id'] = oaiDid.split('=')[1];
+          // Add standard OAI headers that ChatGPT frontend sends
+          nativeHeaders['OAI-Language'] = navigator.language || 'en-US';
+          // Try to get build number from page meta or global
+          try {
+            const buildMeta = document.querySelector('meta[name="build-number"]');
+            if (buildMeta) nativeHeaders['OAI-Client-Build-Number'] = buildMeta.content;
+            if (window.__NEXT_DATA__?.buildId) nativeHeaders['OAI-Client-Version'] = window.__NEXT_DATA__.buildId;
+          } catch(e) {}
+
+          const reqHeaders = { ...nativeHeaders, ...headers };
+          if (url.includes('/estuary/')) {
+            for (const key of Object.keys(reqHeaders)) {
+              if (key.toLowerCase().startsWith('oai-') || key.toLowerCase() === 'authorization') {
+                delete reqHeaders[key];
+              }
+            }
+          }
+          // Strip browser auth headers for external URLs (Azure blob storage)
+          if (url.includes('.oaiusercontent.com/')) {
+            for (const key of Object.keys(reqHeaders)) {
+              if (key.toLowerCase().startsWith('oai-') || key.toLowerCase() === 'authorization') {
+                delete reqHeaders[key];
+              }
+            }
+          }
+          const init = { method, headers: reqHeaders, credentials: url.includes('.oaiusercontent.com/') ? 'omit' : 'include' };
+          if (body !== null && body !== undefined && method !== 'GET' && method !== 'HEAD') {
+            // For binary blob uploads (Azure), convert base64 to Uint8Array
+            if (url.includes('.oaiusercontent.com/') && typeof body === 'string' && body.length > 1000) {
+              const binaryStr = atob(body);
+              const bytes = new Uint8Array(binaryStr.length);
+              for (let i = 0; i < binaryStr.length; i++) {
+                bytes[i] = binaryStr.charCodeAt(i);
+              }
+              init.body = bytes.buffer;
+            } else {
+              init.body = typeof body === 'string' ? body : JSON.stringify(body);
+            }
+            if (typeof body !== 'string' && !Object.keys(init.headers).some((k) => k.toLowerCase() === 'content-type')) {
+              init.headers['Content-Type'] = 'application/json';
+            }
+          }
+          const resp = await fetch(url, init);
+          const contentType = resp.headers.get('content-type') || '';
+          let respBody;
+          let isBase64 = false;
+          
+          if (
+            responseType === 'base64' ||
+            contentType.startsWith('image/') ||
+            contentType.startsWith('audio/') ||
+            contentType.startsWith('video/') ||
+            contentType.startsWith('application/octet-stream')
+          ) {
+            const blob = await resp.blob();
+            respBody = await new Promise((resolve, reject) => {
+              const reader = new FileReader();
+              reader.onloadend = () => {
+                const parts = reader.result.split(',');
+                resolve(parts[1] || parts[0]);
+              };
+              reader.onerror = reject;
+              reader.readAsDataURL(blob);
+            });
+            isBase64 = true;
+          } else {
+            respBody = await resp.text();
+          }
+
+          const respHeaders = {};
+          if (returnHeaders) {
+            resp.headers.forEach((v, k) => { respHeaders[k] = v; });
+          }
+          return { ok: true, status: resp.status, headers: respHeaders, body: respBody, isBase64, finalUrl: resp.url };
+        } catch (e) {
+          return { ok: false, error: String(e && e.message || e) };
+        }
+      },
+    });
+    const result = exec?.result;
+    if (!result || result.ok === false) {
+      sendToAgent({ id, error: result?.error || 'FETCH_FAILED' });
+      return;
+    }
+    sendToAgent({ id, result });
+  } catch (e) {
+    sendToAgent({ id, error: e.message || 'API_REQUEST_FAILED' });
+  } finally {
+    setState(ws && ws.readyState === WebSocket.OPEN ? 'idle' : 'off');
+  }
+}
+
+// PoW Solvers
+async function handleSolvePow(msg) {
+  const id = msg.id || `pow-${Date.now()}`;
+  const params = msg.params || {};
+  const { seed, difficulty } = params.body || params;
+  if (!seed || !difficulty) {
+    sendToAgent({ id, error: 'MISSING_SEED_OR_DIFFICULTY' });
+    return;
+  }
+  setState('running');
+  try {
+    const token = await solveShaPow(seed, difficulty);
+    sendToAgent({ id, result: { ok: true, status: 200, body: JSON.stringify({ token }), headers: {} } });
+  } catch (e) {
+    sendToAgent({ id, error: e.message || 'POW_SOLVE_FAILED' });
+  } finally {
+    setState(ws && ws.readyState === WebSocket.OPEN ? 'idle' : 'off');
+  }
+}
+
+async function handleSolveTurnstile(msg) {
+  const id = msg.id || `turnstile-${Date.now()}`;
+  sendToAgent({ id, error: 'TURNSTILE_SOLVE_NOT_SUPPORTED_IN_BACKGROUND' });
+}
+
+async function solveShaPow(seed, diff) {
+  const diffNum = parseInt(diff, 16) || parseInt(diff);
+  const prefix = '0'.repeat(Math.ceil(Math.log2(diffNum + 1) / 4));
+  const encoder = new TextEncoder();
+  for (let nonce = 0; nonce < 1000000; nonce++) {
+    const input = `${seed}${nonce}`;
+    const hashBuffer = await crypto.subtle.digest('SHA-256', encoder.encode(input));
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    if (hashHex.startsWith(prefix)) {
+      return `gAAAAAB${btoa(input)}`;
+    }
+  }
+  return `gAAAAAB${btoa(seed + '0')}`;
+}
+
+async function getChatGPTTab() {
+  const tabs = await chrome.tabs.query({ url: CHATGPT_TAB_URLS });
+  if (tabs.length > 0) return tabs[0];
+  return await chrome.tabs.create({ url: CHATGPT_URL, active: false });
+}
+
+async function handleFullConversation(msg) {
+  const id = msg.id || `conv-${Date.now()}`;
+  const params = msg.params || {};
+  const { prompt, model = 'auto', conversation_id, thinking_effort, attachments } = params;
+  if (!prompt) {
+    sendToAgent({ id, error: 'MISSING_PROMPT' });
+    return;
+  }
+  setState('running');
+  try {
+    const tab = await getChatGPTTab();
+    const targetUrl = conversation_id ? `https://chatgpt.com/c/${conversation_id}` : CHATGPT_URL;
+    const isTargetConv = !!conversation_id;
+    const isTabConv = tab.url && tab.url.includes('/c/');
+    let needsNavigation = false;
+    if (isTargetConv) {
+      if (!tab.url || !tab.url.startsWith(targetUrl)) {
+        needsNavigation = true;
+      }
+    } else {
+      if (!tab.url || isTabConv || !tab.url.startsWith(CHATGPT_URL)) {
+        needsNavigation = true;
+      }
+    }
+
+    if (needsNavigation) {
+      console.log(`[ChatGPT Bridge] Navigating tab ${tab.id} to ${targetUrl}`);
+      await chrome.tabs.update(tab.id, { url: targetUrl });
+      await waitForTabReady(tab.id);
+      await sleep(2000); // Allow time for conversation DOM to load historical message IDs
+    } else {
+      await waitForTabReady(tab.id);
+    }
+    await sleep(250);
+    const [exec] = await chrome.scripting.executeScript({
+      target: { tabId: tab.id },
+      world: 'MAIN',
+      args: [{ prompt, model, conversation_id, attachments }],
+      func: async ({ prompt, model, conversation_id, attachments }) => {
+        const previousBridgeFlag = window.__CHATGPT_BRIDGE_ACTIVE__;
+        window.__CHATGPT_BRIDGE_ACTIVE__ = true;
+        try {
+          // Step 1: Get access token from session
+          const sessResp = await fetch('/api/auth/session', { credentials: 'include' });
+          if (!sessResp.ok) return { ok: false, error: `session_http_${sessResp.status}` };
+          const sessData = await sessResp.json();
+          const accessToken = sessData.accessToken;
+          if (!accessToken) return { ok: false, error: 'NO_ACCESS_TOKEN' };
+
+          // Build native headers (Device-Id, Language, Build version)
+          const nativeHeaders = {};
+          const cookies = document.cookie.split(';').map(c => c.trim());
+          const oaiDid = cookies.find(c => c.startsWith('oai-did='));
+          if (oaiDid) nativeHeaders['OAI-Device-Id'] = oaiDid.split('=')[1];
+          nativeHeaders['OAI-Language'] = navigator.language || 'en-US';
+          try {
+            const buildMeta = document.querySelector('meta[name="build-number"]');
+            if (buildMeta) nativeHeaders['OAI-Client-Build-Number'] = buildMeta.content;
+            if (window.__NEXT_DATA__?.buildId) nativeHeaders['OAI-Client-Version'] = window.__NEXT_DATA__.buildId;
+          } catch(e) {}
+
+          const encodeConfig = (cfg) => btoa(unescape(encodeURIComponent(JSON.stringify(cfg))));
+
+          // Step 2: Build browser config for requirements/PoW tokens
+          const buildConfig = () => {
+            const d = new Date();
+            const dateStr = d.toString();
+            const getUserMedia = navigator.webkitGetUserMedia || navigator.getUserMedia;
+            const mediaSig = getUserMedia ? `webkitGetUserMedia−${String(getUserMedia)}` : `hardwareConcurrency−${navigator.hardwareConcurrency}`;
+
+            return [
+              screen.width + screen.height,
+              dateStr,
+              4294705152,
+              0,
+              navigator.userAgent,
+              null,
+              window.__NEXT_DATA__?.buildId || "",
+              navigator.language || "en-US",
+              (navigator.languages || [navigator.language]).join(','),
+              0,
+              mediaSig,
+              'location',
+              'self',
+              performance.now() * 1000,
+              crypto.randomUUID(),
+              '',
+              navigator.hardwareConcurrency,
+              Date.now() - performance.now(),
+            ];
+          };
+
+          const generatePToken = () => {
+            const cfg = buildConfig();
+            const started = Date.now();
+            cfg[3] = 1;
+            cfg[9] = Date.now() - started;
+            return { token: 'gAAAAAC' + encodeConfig(cfg), config: cfg };
+          };
+
+          const generated = generatePToken();
+          const pToken = generated.token;
+
+          // Step 3: Get chat requirements
+          const reqHeaders = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+            ...nativeHeaders,
+          };
+          const reqResp = await fetch('/backend-api/sentinel/chat-requirements', {
+            method: 'POST',
+            headers: reqHeaders,
+            credentials: 'include',
+            body: JSON.stringify({ p: pToken }),
+          });
+          if (!reqResp.ok) return { ok: false, error: `requirements_http_${reqResp.status}` };
+          const reqData = await reqResp.json();
+          const chatToken = reqData.token;
+
+          // Step 4: Solve PoW if required
+          let proofToken = null;
+          if (reqData.proofofwork?.required) {
+            const seed = reqData.proofofwork.seed;
+            const difficulty = reqData.proofofwork.difficulty;
+            const fnvHash = (input) => {
+              let h = 2166136261 >>> 0;
+              for (let i = 0; i < input.length; i++) {
+                h ^= input.charCodeAt(i);
+                h = Math.imul(h, 16777619) >>> 0;
+              }
+              h ^= h >>> 16;
+              h = Math.imul(h, 2246822507) >>> 0;
+              h ^= h >>> 13;
+              h = Math.imul(h, 3266489909) >>> 0;
+              h ^= h >>> 16;
+              return (h >>> 0).toString(16).padStart(8, '0');
+            };
+            const powStarted = Date.now();
+            const config = generated.config.slice();
+            for (let nonce = 0; nonce < 500000; nonce++) {
+              config[3] = nonce;
+              config[9] = Date.now() - powStarted;
+              const encoded = encodeConfig(config);
+              if (fnvHash(seed + encoded).slice(0, difficulty.length) <= difficulty) {
+                proofToken = 'gAAAAAB' + encoded + '~S';
+                break;
+              }
+            }
+            if (!proofToken) {
+              return { ok: false, error: 'POW_SOLVE_FAILED' };
+            }
+          }
+
+          // Step 5: Solve turnstile if required
+          let turnstileToken = null;
+          if (reqData.turnstile?.required) {
+            if (typeof turnstile !== 'undefined') {
+              try { turnstileToken = turnstile.getResponse(); } catch(e) {}
+            }
+            if (!turnstileToken) {
+              const el = document.querySelector('[name="cf-turnstile-response"]');
+              if (el) turnstileToken = el.value;
+            }
+            // If still no token, try to render a new turnstile
+            if (!turnstileToken && typeof turnstile !== 'undefined' && reqData.turnstile.dx) {
+              try {
+                const container = document.createElement('div');
+                container.style.display = 'none';
+                document.body.appendChild(container);
+                await new Promise((resolve) => {
+                  turnstile.render(container, {
+                    sitekey: reqData.turnstile.sitekey || '0x4AAAAAAAx1CyDNL8zOEPe7',
+                    callback: (token) => { turnstileToken = token; resolve(); },
+                    'error-callback': () => resolve(),
+                    timeout: 10000,
+                  });
+                  setTimeout(resolve, 15000);
+                });
+                container.remove();
+              } catch(e) {}
+            }
+          }
+
+          // Resolve target conversation ID
+          let resolvedConversationId = conversation_id || null;
+
+          // Resolve parent message ID
+          let parentId = 'client-created-root';
+          if (resolvedConversationId) {
+            try {
+              const convUrl = `/backend-api/conversation/${resolvedConversationId}`;
+              const convDetailResp = await fetch(convUrl, {
+                headers: {
+                  'Authorization': `Bearer ${accessToken}`,
+                  ...nativeHeaders,
+                },
+                credentials: 'include',
+              });
+              if (convDetailResp.ok) {
+                const convData = await convDetailResp.json();
+                if (convData.current_node) {
+                  parentId = convData.current_node;
+                  console.log(`[ChatGPT Bridge] Resolved parent message ID from API: ${parentId}`);
+                }
+              }
+            } catch (e) {
+              console.error('[ChatGPT Bridge] Failed to fetch conversation detail:', e);
+            }
+
+            if (parentId === 'client-created-root') {
+              const msgEls = Array.from(document.querySelectorAll('[data-message-id]'));
+              if (msgEls.length > 0) {
+                const lastId = msgEls[msgEls.length - 1].getAttribute('data-message-id');
+                if (lastId) {
+                  parentId = lastId;
+                  console.log(`[ChatGPT Bridge] Resolved parent message ID from DOM: ${parentId}`);
+                }
+              }
+            }
+          }
+
+          return {
+            ok: true,
+            accessToken,
+            nativeHeaders,
+            chatToken,
+            proofToken,
+            turnstileToken,
+            parentId,
+            resolvedConversationId
+          };
+        } catch (e) {
+          return { ok: false, error: e.message || 'UNKNOWN_ERROR' };
+        } finally {
+          window.__CHATGPT_BRIDGE_ACTIVE__ = previousBridgeFlag;
+        }
+      },
+    });
+    const prep = exec?.result;
+    if (!prep || !prep.ok) {
+      sendToAgent({ id, error: prep?.error || 'CONVERSATION_PREPARATION_FAILED', result: prep });
+      return;
+    }
+
+    const echoStart = Math.max(1000, Math.floor(performance.now()));
+    const echoEnd = echoStart + 1000 + Math.floor(Math.random() * 500);
+    const convHeaders = {
+      'Authorization': `Bearer ${prep.accessToken}`,
+      'Content-Type': 'application/json',
+      'Accept': 'text/event-stream',
+      'openai-sentinel-chat-requirements-token': prep.chatToken,
+      'oai-echo-logs': `0,${echoStart},1,${echoEnd}`,
+      ...prep.nativeHeaders,
+    };
+    if (prep.proofToken) convHeaders['openai-sentinel-proof-token'] = prep.proofToken;
+    if (prep.turnstileToken) convHeaders['openai-sentinel-turnstile-token'] = prep.turnstileToken;
+
+    let actualModel = model;
+    let resolvedThinkingEffort = thinking_effort || null;
+    if (model && model.includes('thinking')) {
+      if (model.includes('-extended')) {
+        resolvedThinkingEffort = 'extended';
+        actualModel = model.replace('-extended', '');
+      } else if (model.includes('-standard')) {
+        resolvedThinkingEffort = 'standard';
+        actualModel = model.replace('-standard', '');
+      } else if (!resolvedThinkingEffort) {
+        resolvedThinkingEffort = 'standard';
+      }
+    }
+
+    const commonConversationFields = {
+      action: 'next',
+      model: actualModel,
+      timezone_offset_min: new Date().getTimezoneOffset(),
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC',
+      history_and_training_disabled: false,
+      fork_from_shared_post: false,
+      force_paragen: false,
+      force_rate_limit: false,
+      conversation_mode: { kind: 'primary_assistant' },
+      enable_message_followups: true,
+      system_hints: [],
+      supports_buffering: true,
+      supported_encodings: ['v1'],
+      paragen_cot_summary_display_override: 'allow',
+      force_parallel_switch: 'auto',
+    };
+    if (resolvedThinkingEffort) {
+      commonConversationFields.thinking_effort = resolvedThinkingEffort;
+    }
+
+    const prepareBody = {
+      ...commonConversationFields,
+      parent_message_id: prep.parentId,
+    };
+    if (prep.resolvedConversationId) {
+      prepareBody.conversation_id = prep.resolvedConversationId;
+    }
+
+    // Build message content - support multimodal (text + image attachments)
+    const messageParts = [prompt];
+    const messageAttachments = [];
+    if (attachments && attachments.length > 0) {
+      for (const att of attachments) {
+        messageAttachments.push({
+          id: att.id,
+          name: att.name || 'image.png',
+          size: att.size || 0,
+          mime_type: att.mime_type || 'image/png',
+          width: att.width || null,
+          height: att.height || null,
+        });
+      }
+    }
+
+    const messageContent = attachments && attachments.length > 0
+      ? { content_type: 'multimodal_text', parts: messageParts }
+      : { content_type: 'text', parts: [prompt] };
+
+    const userMessage = {
+      id: crypto.randomUUID(),
+      author: { role: 'user' },
+      content: messageContent,
+      metadata: {
+        selected_github_repos: [],
+        selected_all_github_repos: false,
+        serialization_metadata: { custom_symbol_offsets: [] },
+      },
+      create_time: Math.round(Date.now()) / 1000,
+    };
+    if (messageAttachments.length > 0) {
+      userMessage.metadata.attachments = messageAttachments;
+    }
+
+    const convBody = {
+      ...commonConversationFields,
+      messages: [userMessage],
+      parent_message_id: prep.parentId,
+      websocket_request_id: crypto.randomUUID(),
+      client_contextual_info: {
+        is_dark_mode: false,
+        time_since_loaded: 0,
+        page_height: 800,
+        page_width: 1200,
+        pixel_ratio: 1,
+        screen_height: 1080,
+        screen_width: 1920,
+      },
+    };
+    if (prep.resolvedConversationId) {
+      convBody.conversation_id = prep.resolvedConversationId;
+    }
+
+    const prepareHeaders = {
+      ...convHeaders,
+      'Accept': 'application/json',
+      'x-conduit-token': 'no-token',
+    };
+    const prepareResp = await fetch('https://chatgpt.com/backend-api/f/conversation/prepare', {
+      method: 'POST',
+      headers: prepareHeaders,
+      credentials: 'include',
+      body: JSON.stringify(prepareBody),
+    });
+    if (!prepareResp.ok) {
+      const errText = await prepareResp.text();
+      sendToAgent({ id, error: `prepare_http_${prepareResp.status}: ${errText.slice(0, 500)}` });
+      return;
+    }
+    const prepareText = await prepareResp.text();
+    let conduitToken = 'no-token';
+    try {
+      const prepared = JSON.parse(prepareText);
+      conduitToken = prepared.conduit_token || prepared.conduitToken || prepared.token || conduitToken;
+    } catch(e) {}
+
+    const finalHeaders = {
+      ...convHeaders,
+      'x-conduit-token': conduitToken,
+    };
+    const convResp = await fetch('https://chatgpt.com/backend-api/f/conversation', {
+      method: 'POST',
+      headers: finalHeaders,
+      credentials: 'include',
+      body: JSON.stringify(convBody),
+    });
+
+    if (!convResp.ok) {
+      const errText = await convResp.text();
+      sendToAgent({ id, error: `conversation_http_${convResp.status}: ${errText.slice(0, 500)}` });
+      return;
+    }
+
+    const text = await convResp.text();
+    let convId = '';
+    const parseSSEFinal = (raw) => {
+      let snapshot = '';
+      let delta = '';
+      let fileIds = new Set();
+      let currentContentType = '';
+      let currentRole = '';
+      const extractParts0 = (obj) => {
+        const role = obj?.message?.author?.role;
+        if (role !== 'assistant' && role !== 'tool') return '';
+        const parts = obj?.message?.content?.parts;
+        if (!Array.isArray(parts)) return '';
+        for (const part of parts) {
+          if (part && typeof part === 'object' && part.content_type === 'image_asset_pointer' && part.asset_pointer) {
+            const match = part.asset_pointer.match(/(?:file-service|sediment):\/\/(file[_-][\w-]+)/);
+            if (match && match[1]) {
+              const fileId = match[1];
+              const isAttachment = attachments && attachments.some(att => att.id === fileId);
+              if (!isAttachment) {
+                fileIds.add(fileId);
+              }
+            }
+          }
+        }
+        return typeof parts[0] === 'string' ? parts[0] : '';
+      };
+
+      const processDeltaObj = (ev) => {
+        if (
+          typeof ev.p === 'string' &&
+          ev.p.includes('/message/content/parts/0')
+        ) {
+          if (ev.o === 'replace' && typeof ev.v === 'string') {
+            delta = ev.v;
+          } else if ((ev.o === undefined || ev.o === 'append') && typeof ev.v === 'string') {
+            delta += ev.v;
+          }
+        } else if (ev.p === undefined && typeof ev.v === 'string') {
+          if (currentContentType === 'text' || currentContentType === 'multimodal_text' || currentContentType === '') {
+            delta += ev.v;
+          }
+        } else if (ev.o === 'patch' && Array.isArray(ev.v)) {
+          for (const sub of ev.v) {
+            processDeltaObj(sub);
+          }
+        }
+      };
+
+      const lines = raw.split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data:')) continue;
+        const data = trimmed.slice(5).trim();
+        if (!data || data === '[DONE]') continue;
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.conversation_id) {
+            convId = parsed.conversation_id;
+          }
+          if (parsed.v && typeof parsed.v === 'object') {
+            if (parsed.v.conversation_id) {
+              convId = parsed.v.conversation_id;
+            }
+            if (parsed.v.message) {
+              currentContentType = parsed.v.message.content?.content_type || '';
+              currentRole = parsed.v.message.author?.role || '';
+            }
+          } else if (parsed.message) {
+            currentContentType = parsed.message.content?.content_type || '';
+            currentRole = parsed.message.author?.role || '';
+          }
+          const direct = extractParts0(parsed);
+          if (direct) snapshot = direct;
+          if (parsed.v && typeof parsed.v === 'object') {
+            const nested = extractParts0(parsed.v);
+            if (nested) snapshot = nested;
+          }
+          processDeltaObj(parsed);
+        } catch(e) {}
+      }
+      let out = snapshot;
+      if (delta) {
+        if (delta.length > snapshot.length) {
+            out = delta;
+        } else if (snapshot && !snapshot.includes(delta)) {
+            out = snapshot + delta;
+        }
+      }
+      if (fileIds.size > 0) {
+        let imageMarkdown = '\n\n';
+        for (const fileId of fileIds) {
+          imageMarkdown += `![Generated Image](http://127.0.0.1:9225/api/download?file_id=${fileId}&prompt=${encodeURIComponent(prompt)})\n`;
+        }
+        out += imageMarkdown;
+      }
+      return out;
+    };
+    const assistantText = parseSSEFinal(text);
+    if (!assistantText) {
+      sendToAgent({
+        id,
+        error: `EMPTY_ASSISTANT_RESPONSE raw_len=${text.length} raw=${text.replace(/\s+/g, ' ').slice(0, 500)}`,
+        result: { rawText: text }
+      });
+      return;
+    }
+
+    sendToAgent({ id, result: { ok: true, status: 200, body: assistantText, rawText: text, conversation_id: convId || prep.resolvedConversationId, headers: {} } });
+  } catch (e) {
+    sendToAgent({ id, error: e.message || 'FULL_CONVERSATION_FAILED' });
+  } finally {
+    setState(ws && ws.readyState === WebSocket.OPEN ? 'idle' : 'off');
+  }
+}
+
+async function waitForTabReady(tabId, timeout = 30000) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    const tab = await chrome.tabs.get(tabId);
+    if (tab.status === 'complete') return;
+    await sleep(300);
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

chatgpt-free-api/gpt-extension/manifest.json

@@ -0,0 +1,28 @@
+{
+  "manifest_version": 3,
+  "name": "Gpt Agent Api",
+  "version": "1.0.0",
+  "description": "Auto-syncs ChatGPT cookies to your local ChatGPT Free API server",
+  "icons": {
+    "16": "icon16.png",
+    "48": "icon48.png",
+    "128": "icon128.png"
+  },
+  "permissions": ["cookies", "storage", "alarms", "tabs", "scripting"],
+  "host_permissions": [
+    "https://chatgpt.com/*",
+    "https://chat.openai.com/*"
+  ],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_popup": "popup.html",
+    "default_title": "GPT Agent Sync",
+    "default_icon": {
+      "16": "icon16.png",
+      "48": "icon48.png",
+      "128": "icon128.png"
+    }
+  }
+}

chatgpt-free-api/gpt-extension/popup.html

@@ -0,0 +1,158 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <style>
+    :root {
+      --primary: #10a37f;
+      --secondary: #1a7f64;
+      --bg: #0b0f19;
+      --card: rgba(255, 255, 255, 0.05);
+      --text: #ffffff;
+      --text-muted: #a0aec0;
+      --success: #10b981;
+      --danger: #ef4444;
+    }
+
+    body {
+      font-family: 'Inter', system-ui, -apple-system, sans-serif;
+      background: linear-gradient(135deg, #0b0f19 0%, #111827 100%);
+      color: var(--text);
+      width: 320px;
+      margin: 0;
+      padding: 16px;
+      box-sizing: border-box;
+      overflow: hidden;
+    }
+
+    .container {
+      display: flex;
+      flex-direction: column;
+      gap: 16px;
+    }
+
+    .header {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+    }
+
+    .logo-glow {
+      width: 24px;
+      height: 24px;
+      background: linear-gradient(45deg, var(--primary), var(--secondary));
+      border-radius: 50%;
+      box-shadow: 0 0 12px var(--primary);
+    }
+
+    h2 {
+      margin: 0;
+      font-size: 18px;
+      font-weight: 700;
+      letter-spacing: -0.5px;
+      background: linear-gradient(90deg, #ffffff, var(--text-muted));
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+    }
+
+    .status-card {
+      background: var(--card);
+      border: 1px solid rgba(255, 255, 255, 0.08);
+      border-radius: 12px;
+      padding: 14px;
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+      backdrop-filter: blur(10px);
+    }
+
+    .status-row {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+
+    .status-label {
+      color: var(--text-muted);
+      font-size: 13px;
+    }
+
+    .status-value {
+      font-weight: 600;
+      font-size: 13px;
+      display: flex;
+      align-items: center;
+      gap: 6px;
+    }
+
+    .badge {
+      display: inline-block;
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+    }
+
+    .badge.connected {
+      background-color: var(--success);
+      box-shadow: 0 0 8px var(--success);
+    }
+
+    .badge.disconnected {
+      background-color: var(--danger);
+      box-shadow: 0 0 8px var(--danger);
+    }
+
+    .badge.running {
+      background-color: #f59e0b;
+      box-shadow: 0 0 8px #f59e0b;
+    }
+
+    .btn-sync {
+      background: linear-gradient(90deg, var(--primary) 0%, var(--secondary) 100%);
+      color: #ffffff;
+      border: none;
+      border-radius: 8px;
+      padding: 10px 16px;
+      font-weight: 600;
+      font-size: 14px;
+      cursor: pointer;
+      transition: all 0.2s ease;
+      box-shadow: 0 4px 15px rgba(16, 163, 127, 0.3);
+    }
+
+    .btn-sync:hover {
+      transform: translateY(-1px);
+      box-shadow: 0 6px 20px rgba(16, 163, 127, 0.55);
+    }
+
+    .btn-sync:active {
+      transform: translateY(1px);
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <div class="logo-glow"></div>
+      <h2>Gpt Agent Api</h2>
+    </div>
+
+    <div class="status-card">
+      <div class="status-row">
+        <span class="status-label">Server Connection</span>
+        <span class="status-value" id="conn-status">
+          <span class="badge disconnected" id="status-badge"></span>
+          <span id="status-text">Disconnected</span>
+        </span>
+      </div>
+      <div class="status-row">
+        <span class="status-label">Last Sync</span>
+        <span class="status-value" id="last-sync" style="color: var(--text-muted);">Never</span>
+      </div>
+    </div>
+
+    <button class="btn-sync" id="sync-btn">Force Sync Cookies</button>
+  </div>
+  <script src="popup.js"></script>
+</body>
+</html>

chatgpt-free-api/gpt-extension/popup.js

@@ -0,0 +1,56 @@
+document.addEventListener('DOMContentLoaded', () => {
+  const statusBadge = document.getElementById('status-badge');
+  const statusText = document.getElementById('status-text');
+  const lastSync = document.getElementById('last-sync');
+  const syncBtn = document.getElementById('sync-btn');
+
+  function updateUI() {
+    chrome.runtime.sendMessage({ type: 'GET_STATUS' }, (response) => {
+      if (chrome.runtime.lastError) return;
+      if (!response) return;
+
+      if (response.state === 'running') {
+        statusBadge.className = 'badge running';
+        statusText.innerText = 'Active';
+        statusText.style.color = '#f59e0b';
+      } else if (response.connected) {
+        statusBadge.className = 'badge connected';
+        statusText.innerText = 'Connected';
+        statusText.style.color = '#10b981';
+      } else {
+        statusBadge.className = 'badge disconnected';
+        statusText.innerText = 'Disconnected';
+        statusText.style.color = '#ef4444';
+      }
+
+      if (response.lastSyncTime) {
+        const date = new Date(response.lastSyncTime);
+        lastSync.innerText = date.toLocaleTimeString();
+      } else {
+        lastSync.innerText = 'Never';
+      }
+    });
+  }
+
+  // Initial update
+  updateUI();
+
+  // Listen for real-time updates from background worker
+  chrome.runtime.onMessage.addListener((msg) => {
+    if (msg.type === 'COOKIE_SYNC_UPDATE') {
+      updateUI();
+    }
+  });
+
+  syncBtn.addEventListener('click', () => {
+    syncBtn.disabled = true;
+    syncBtn.innerText = 'Syncing...';
+    chrome.runtime.sendMessage({ type: 'FORCE_SYNC' }, () => {
+      setTimeout(() => {
+        syncBtn.disabled = false;
+        syncBtn.innerText = 'Force Sync Cookies';
+        updateUI();
+      }, 800);
+    });
+  });
+});

chatgpt-free-api/handlers.go

@@ -0,0 +1,483 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/gorilla/websocket"
+)
+
+type ChatRequest struct {
+	Prompt          string `json:"prompt"`
+	WaitForResponse bool   `json:"wait_for_response"`
+	ConversationID  string `json:"conversation_id"`
+	Model           string `json:"model"`
+	ThinkingEffort  string `json:"thinking_effort"`
+}
+
+type BulkChatRequest struct {
+	Prompts         []string `json:"prompts"`
+	WaitForResponse bool     `json:"wait_for_response"`
+	DelaySeconds    int      `json:"delay_seconds"`
+}
+
+type ChatResult struct {
+	Prompt   string `json:"prompt"`
+	Response string `json:"response,omitempty"`
+	Error    string `json:"error,omitempty"`
+}
+
+type OpenAIChatMessage struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type OpenAIChatCompletionRequest struct {
+	Model    string              `json:"model"`
+	Messages []OpenAIChatMessage `json:"messages"`
+	Stream   bool                `json:"stream"`
+}
+
+type OpenAIChoice struct {
+	Index        int               `json:"index"`
+	Message      OpenAIChatMessage `json:"message"`
+	FinishReason string            `json:"finish_reason"`
+}
+
+type OpenAIChatCompletionResponse struct {
+	ID      string         `json:"id"`
+	Object  string         `json:"object"`
+	Created int64          `json:"created"`
+	Model   string         `json:"model"`
+	Choices []OpenAIChoice `json:"choices"`
+}
+
+var testUpgrader = websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
+
+func handleWS(w http.ResponseWriter, r *http.Request) {
+	conn, err := testUpgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Printf("WS upgrade error: %v", err)
+		return
+	}
+
+	extMu.Lock()
+	extConn = conn
+	if !reloadTriggered {
+		reloadTriggered = true
+		log.Println("[ws] Sending reload_extension request to sync extension files from disk...")
+		_ = conn.WriteJSON(WSMessage{
+			Method: "reload_extension",
+		})
+	}
+	extMu.Unlock()
+	log.Println("[ws] Extension connected from", r.RemoteAddr)
+
+	defer func() {
+		extMu.Lock()
+		if extConn == conn {
+			extConn = nil
+		}
+		extMu.Unlock()
+		conn.Close()
+		log.Println("Extension disconnected")
+
+		// Fail all pending channels
+		pendingMu.Lock()
+		for id, ch := range pending {
+			ch <- WSMessage{
+				ID:    id,
+				Error: "extension disconnected",
+			}
+		}
+		pending = map[string]chan WSMessage{}
+		pendingMu.Unlock()
+	}()
+
+	for {
+		var msg WSMessage
+		if err := conn.ReadJSON(&msg); err != nil {
+			log.Printf("[ws] read closed: %v", err)
+			return
+		}
+		if msg.Type != "" {
+			log.Printf("[ws] event: type=%s", msg.Type)
+		}
+		handleExtensionMessage(msg)
+	}
+}
+
+func handleHealth(w http.ResponseWriter, _ *http.Request) {
+	writeJSON(w, map[string]any{"ok": true, "mode": "chatgpt-api-bridge", "extensionConnected": isExtensionConnected(), "extension": getExtensionInfo()})
+}
+
+func handleCallback(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	var msg WSMessage
+	if err := json.NewDecoder(r.Body).Decode(&msg); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	handleExtensionMessage(msg)
+	writeJSON(w, map[string]any{"ok": true})
+}
+
+func handleChat(w http.ResponseWriter, r *http.Request) {
+	req := ChatRequest{WaitForResponse: true}
+	if r.Method == http.MethodGet {
+		req.Prompt = r.URL.Query().Get("prompt")
+		req.ConversationID = r.URL.Query().Get("conversation_id")
+		req.Model = r.URL.Query().Get("model")
+		req.ThinkingEffort = r.URL.Query().Get("thinking_effort")
+	} else if r.Method == http.MethodPost {
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+	} else {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	if req.Prompt == "" {
+		http.Error(w, `{"error":"prompt required"}`, http.StatusBadRequest)
+		return
+	}
+	if req.Model == "" {
+		req.Model = cfg.DefaultModel
+	}
+
+	if req.ConversationID == "new" {
+		req.ConversationID = ""
+		clearActiveConversationID()
+	}
+
+	log.Printf("[chat] sending prompt via API mode (model=%s, thinking_effort=%s, conversation_id=%s): %s", req.Model, req.ThinkingEffort, req.ConversationID, snippet(req.Prompt, 50))
+	response, newConvID, err := sendChatWithConversation(req.Prompt, req.ConversationID, req.Model, req.ThinkingEffort)
+	if err != nil {
+		writeJSONStatus(w, http.StatusBadGateway, map[string]any{"ok": false, "error": err.Error()})
+		return
+	}
+
+	if newConvID != "" {
+		setActiveConversationID(newConvID)
+	}
+
+	// Scan the response for download links to include in the JSON
+	var images []string
+	var fileIDRegexp = regexp.MustCompile(`(file_[0-9a-fA-F]{32}|file-[a-zA-Z0-9_-]{24,36})`)
+	matches := fileIDRegexp.FindAllString(response, -1)
+	if len(matches) > 0 {
+		seen := make(map[string]bool)
+		for _, id := range matches {
+			if !seen[id] {
+				seen[id] = true
+				name := getPromptFilename(req.Prompt, id)
+				images = append(images, "output/"+name+".png")
+			}
+		}
+	}
+
+	writeJSON(w, map[string]any{
+		"ok":              true,
+		"response":        response,
+		"conversation_id": newConvID,
+		"images":          images,
+	})
+}
+
+func handleChatBulk(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	req := BulkChatRequest{WaitForResponse: true, DelaySeconds: cfg.BulkDelaySeconds}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if len(req.Prompts) == 0 {
+		http.Error(w, `{"error":"prompts required"}`, http.StatusBadRequest)
+		return
+	}
+	results := make([]ChatResult, 0, len(req.Prompts))
+	for i, prompt := range req.Prompts {
+		text, _, err := sendChat(prompt)
+		item := ChatResult{Prompt: prompt, Response: text}
+		if err != nil {
+			item.Error = err.Error()
+		}
+		results = append(results, item)
+		if i < len(req.Prompts)-1 && req.DelaySeconds > 0 {
+			time.Sleep(time.Duration(req.DelaySeconds) * time.Second)
+		}
+	}
+	writeJSON(w, map[string]any{"ok": true, "count": len(results), "results": results})
+}
+
+func handleChatEdit(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	// Parse multipart form (max 32MB)
+	if err := r.ParseMultipartForm(32 << 20); err != nil {
+		http.Error(w, `{"error":"invalid multipart form: `+err.Error()+`"}`, http.StatusBadRequest)
+		return
+	}
+
+	prompt := r.FormValue("prompt")
+	if prompt == "" {
+		http.Error(w, `{"error":"prompt required"}`, http.StatusBadRequest)
+		return
+	}
+
+	conversationID := r.FormValue("conversation_id")
+	model := r.FormValue("model")
+	if model == "" {
+		model = cfg.DefaultModel
+	}
+
+	if conversationID == "new" {
+		conversationID = ""
+		clearActiveConversationID()
+	}
+
+	var attachments []FileAttachment
+
+	// Handle image upload if present
+	file, header, err := r.FormFile("image")
+	if err == nil {
+		defer file.Close()
+
+		// Save to temp file
+		_ = os.MkdirAll("output/tmp", 0755)
+		defer os.Remove("output/tmp")
+		tmpPath := filepath.Join("output", "tmp", header.Filename)
+		out, err := os.Create(tmpPath)
+		if err != nil {
+			writeJSONStatus(w, http.StatusInternalServerError, map[string]any{"ok": false, "error": "save temp file: " + err.Error()})
+			return
+		}
+		if _, err := io.Copy(out, file); err != nil {
+			out.Close()
+			writeJSONStatus(w, http.StatusInternalServerError, map[string]any{"ok": false, "error": "copy file: " + err.Error()})
+			return
+		}
+		out.Close()
+		defer os.Remove(tmpPath)
+
+		log.Printf("[chat-edit] Uploading image %s to ChatGPT...", header.Filename)
+		att, err := uploadFileToChatGPT(tmpPath)
+		if err != nil {
+			writeJSONStatus(w, http.StatusBadGateway, map[string]any{"ok": false, "error": "upload image: " + err.Error()})
+			return
+		}
+		attachments = append(attachments, *att)
+		log.Printf("[chat-edit] Image uploaded: %s (file_id: %s)", header.Filename, att.ID)
+	}
+
+	log.Printf("[chat-edit] sending prompt with %d attachment(s): %s", len(attachments), snippet(prompt, 50))
+
+	response, newConvID, err := sendChatWithConversationAndAttachments(prompt, conversationID, model, cfg.DefaultThinkingEffort, attachments)
+	if err != nil {
+		writeJSONStatus(w, http.StatusBadGateway, map[string]any{"ok": false, "error": err.Error()})
+		return
+	}
+
+	if newConvID != "" {
+		setActiveConversationID(newConvID)
+	}
+
+	// Scan response for image downloads
+	var images []string
+	var editFileIDRegexp = regexp.MustCompile(`(file_[0-9a-fA-F]{32}|file-[a-zA-Z0-9_-]{24,36})`)
+	matches := editFileIDRegexp.FindAllString(response, -1)
+	if len(matches) > 0 {
+		uploadedIDs := make(map[string]bool)
+		for _, att := range attachments {
+			uploadedIDs[att.ID] = true
+		}
+		seen := make(map[string]bool)
+		for _, id := range matches {
+			if !seen[id] && !uploadedIDs[id] {
+				seen[id] = true
+				name := getPromptFilename(prompt, id)
+				images = append(images, "output/"+name+".png")
+			}
+		}
+	}
+
+	writeJSON(w, map[string]any{
+		"ok":              true,
+		"response":        response,
+		"conversation_id": newConvID,
+		"images":          images,
+	})
+}
+
+func handleSniffs(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		sniffMu.Lock()
+		out := append([]SniffedRequest(nil), sniffs...)
+		sniffMu.Unlock()
+		writeJSON(w, map[string]any{"ok": true, "count": len(out), "sniffs": out})
+	case http.MethodDelete:
+		sniffMu.Lock()
+		sniffs = nil
+		sniffMu.Unlock()
+		writeJSON(w, map[string]any{"ok": true, "cleared": true})
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func handleOpenAIChat(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req OpenAIChatCompletionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	if len(req.Messages) == 0 {
+		http.Error(w, `{"error":{"message":"messages array is empty"}}`, http.StatusBadRequest)
+		return
+	}
+
+	// Extract prompt from messages (last user message)
+	var prompt string
+	for i := len(req.Messages) - 1; i >= 0; i-- {
+		if req.Messages[i].Role == "user" {
+			prompt = req.Messages[i].Content
+			break
+		}
+	}
+	if prompt == "" {
+		prompt = req.Messages[len(req.Messages)-1].Content
+	}
+
+	model := req.Model
+	if model == "" {
+		model = cfg.DefaultModel
+	}
+
+	conversationID := getActiveConversationID()
+
+	log.Printf("[openai-chat] received OpenAI request (model=%s, conversation_id=%s), sending prompt: %s", model, conversationID, snippet(prompt, 50))
+	response, newConvID, err := sendChatWithConversation(prompt, conversationID, model, cfg.DefaultThinkingEffort)
+	if err != nil {
+		writeJSONStatus(w, http.StatusBadGateway, map[string]any{
+			"error": map[string]any{
+				"message": err.Error(),
+				"type":     "api_error",
+			},
+		})
+		return
+	}
+
+	if newConvID != "" {
+		setActiveConversationID(newConvID)
+	}
+
+	resp := OpenAIChatCompletionResponse{
+		ID:      "chatcmpl-" + uuid.NewString()[:12],
+		Object:  "chat.completion",
+		Created: time.Now().Unix(),
+		Model:   model,
+		Choices: []OpenAIChoice{
+			{
+				Index: 0,
+				Message: OpenAIChatMessage{
+					Role:    "assistant",
+					Content: response,
+				},
+				FinishReason: "stop",
+			},
+		},
+	}
+
+	writeJSON(w, resp)
+}
+
+func handleDownload(w http.ResponseWriter, r *http.Request) {
+	fileID := r.URL.Query().Get("file_id")
+	if fileID == "" {
+		http.Error(w, `{"error":"file_id required"}`, http.StatusBadRequest)
+		return
+	}
+
+	// 1. Determine local path based on prompt mapping
+	prompt := getFilePrompt(fileID)
+	// Also check if prompt is passed in query string as backup
+	if prompt == "" {
+		prompt = r.URL.Query().Get("prompt")
+	}
+
+	var name string
+	var localPath string
+	if prompt != "" {
+		name = getPromptFilename(prompt, fileID)
+		localPath = fmt.Sprintf("output/%s.png", name)
+	} else {
+		localPath = fmt.Sprintf("output/%s.png", fileID)
+	}
+
+	var data []byte
+	var err error
+
+	// 2. Check if file already exists locally
+	if _, err = os.Stat(localPath); err == nil {
+		log.Printf("[download] File %s already exists locally, serving from disk", localPath)
+		data, err = os.ReadFile(localPath)
+		if err != nil {
+			log.Printf("[download] Error reading local file %s: %v, will redownload", localPath, err)
+			data = nil
+		}
+	}
+
+	// 3. If not found or failed to read, download it
+	if len(data) == 0 {
+		data, err = downloadChatGPTFile(fileID)
+		if err != nil {
+			log.Printf("[download] error downloading file %s: %v", fileID, err)
+			writeJSONStatus(w, http.StatusInternalServerError, map[string]any{"ok": false, "error": err.Error()})
+			return
+		}
+
+		// Save file locally to output folder
+		_ = os.MkdirAll("output", 0755)
+		err = os.WriteFile(localPath, data, 0644)
+		if err != nil {
+			log.Printf("[download] error saving file locally to %s: %v", localPath, err)
+		} else {
+			log.Printf("[download] file saved successfully to %s", localPath)
+		}
+	}
+
+	w.Header().Set("Content-Type", "image/png")
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", len(data)))
+	
+	headerFilename := fileID + ".png"
+	if name != "" {
+		headerFilename = name + ".png"
+	}
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", headerFilename))
+	w.Write(data)
+}

chatgpt-free-api/helpers.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+)
+
+func intFromAny(v any) int {
+	switch x := v.(type) {
+	case int:
+		return x
+	case float64:
+		return int(x)
+	case json.Number:
+		i, _ := x.Int64()
+		return int(i)
+	default:
+		return 0
+	}
+}
+
+func boolFromAny(v any) (bool, bool) {
+	switch x := v.(type) {
+	case bool:
+		return x, true
+	default:
+		return false, false
+	}
+}
+
+func redactHeaderValue(key string, value any) any {
+	switch strings.ToLower(key) {
+	case "authorization", "openai-sentinel-chat-requirements-token", "openai-sentinel-proof-token", "openai-sentinel-turnstile-token":
+		return "[redacted]"
+	default:
+		return value
+	}
+}
+
+func writeJSON(w http.ResponseWriter, v any) {
+	writeJSONStatus(w, http.StatusOK, v)
+}
+
+func writeJSONStatus(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(v)
+}

chatgpt-free-api/main.go

@@ -0,0 +1,5 @@
+package main
+
+func main() {
+	Start()
+}

chatgpt-free-api/sniff.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"sync"
+	"time"
+)
+
+type SniffedRequest struct {
+	Time     string         `json:"time"`
+	Source   string         `json:"source,omitempty"`
+	Phase    string         `json:"phase,omitempty"`
+	Method   string         `json:"method,omitempty"`
+	URL      string         `json:"url,omitempty"`
+	Status   int            `json:"status,omitempty"`
+	OK       *bool          `json:"ok,omitempty"`
+	Headers  map[string]any `json:"headers,omitempty"`
+	Payload  string         `json:"payload,omitempty"`
+	Response string         `json:"response,omitempty"`
+	Error    string         `json:"error,omitempty"`
+}
+
+var (
+	sniffMu sync.Mutex
+	sniffs  []SniffedRequest
+)
+
+func sniffFromMessage(msg WSMessage) SniffedRequest {
+	source, _ := msg.Params["source"].(string)
+	phase, _ := msg.Params["phase"].(string)
+	url, _ := msg.Params["url"].(string)
+	payload, _ := msg.Params["payload"].(string)
+	response, _ := msg.Params["response"].(string)
+	errText, _ := msg.Params["error"].(string)
+	status := intFromAny(msg.Params["status"])
+	headers := map[string]any{}
+	if headersMap, ok := msg.Params["headers"].(map[string]any); ok {
+		for k, v := range headersMap {
+			headers[k] = redactHeaderValue(k, v)
+		}
+	}
+	var okPtr *bool
+	if okVal, ok := boolFromAny(msg.Params["ok"]); ok {
+		okPtr = &okVal
+	}
+	if source == "" {
+		source = "unknown"
+	}
+	if phase == "" {
+		phase = "request"
+	}
+	return SniffedRequest{
+		Time:     time.Now().Format(time.RFC3339),
+		Source:   source,
+		Phase:    phase,
+		Method:   msg.Method,
+		URL:      url,
+		Status:   status,
+		OK:       okPtr,
+		Headers:  headers,
+		Payload:  payload,
+		Response: response,
+		Error:    errText,
+	}
+}
+
+func addSniff(sniff SniffedRequest) {
+	sniffMu.Lock()
+	defer sniffMu.Unlock()
+	sniffs = append([]SniffedRequest{sniff}, sniffs...)
+	if len(sniffs) > cfg.MaxSniffs {
+		sniffs = sniffs[:cfg.MaxSniffs]
+	}
+}

chatgpt-free-api/test.sh

@@ -0,0 +1,124 @@
+#!/bin/bash
+
+# Unset proxy variables for local communication
+unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY no_proxy
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[0;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}==================================================${NC}"
+echo -e "${BLUE}        ChatGPT Free API Integration Test          ${NC}"
+echo -e "${BLUE}==================================================${NC}"
+
+# Check if agent is running on port 9225
+echo "🔍 Checking if agent is running on port 9225..."
+if ! curl -s --connect-timeout 2 http://127.0.0.1:9225/health >/dev/null; then
+    echo -e "${RED}❌ Error: Agent is not running on port 9225!${NC}"
+    echo -e "💡 Please start the server separately first by running: ${YELLOW}./agent${NC} or ${YELLOW}go run main.go${NC}"
+    exit 1
+fi
+echo -e "${GREEN}✅ Agent detected on port 9225! Running tests...${NC}"
+
+# Test 1: Check cookie status
+echo -e "\n${BLUE}[Test 1] Checking cookie status...${NC}"
+STATUS_RESP=$(curl -s http://127.0.0.1:9225/api/cookies/status)
+echo "Response: $STATUS_RESP"
+if [[ "$STATUS_RESP" == *"has_cookies\":true"* ]]; then
+    TEST1_STATUS="${GREEN}PASSED${NC}"
+else
+    TEST1_STATUS="${RED}FAILED (No cookies sync)${NC}"
+fi
+
+# Test 2: Send basic chat test
+echo -e "\n${BLUE}[Test 2] Sending basic text chat prompt...${NC}"
+CHAT_RESP=$(curl -s -X POST http://127.0.0.1:9225/api/chat \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "Tell me a short programmer joke."}')
+echo "Response: $CHAT_RESP"
+
+CONV_ID=$(echo "$CHAT_RESP" | grep -o '"conversation_id":"[^"]*' | cut -d'"' -f4)
+if [ -n "$CONV_ID" ]; then
+    TEST2_STATUS="${GREEN}PASSED${NC}"
+else
+    TEST2_STATUS="${RED}FAILED (No response or conversation ID)${NC}"
+fi
+
+# Test 3: Conversation thread continuity
+if [ -n "$CONV_ID" ]; then
+    echo -e "\n${BLUE}[Test 3] Testing thread continuity...${NC}"
+    THREAD_RESP=$(curl -s -X POST http://127.0.0.1:9225/api/chat \
+      -H "Content-Type: application/json" \
+      -d "{\"prompt\": \"Explain that joke.\", \"conversation_id\": \"$CONV_ID\"}")
+    echo "Response: $THREAD_RESP"
+    if [[ "$THREAD_RESP" == *"ok\":true"* ]]; then
+        TEST3_STATUS="${GREEN}PASSED${NC}"
+    else
+        TEST3_STATUS="${RED}FAILED (Thread reply failed)${NC}"
+    fi
+else
+    TEST3_STATUS="${YELLOW}SKIPPED (No conversation ID)${NC}"
+fi
+
+# Test 4: Bulk chat request
+echo -e "\n${BLUE}[Test 4] Testing bulk chat request...${NC}"
+BULK_RESP=$(curl -s -X POST http://127.0.0.1:9225/api/chat/bulk \
+  -H "Content-Type: application/json" \
+  -d '{"prompts": ["What is 2+2?", "What is Go?"], "wait_for_response": true}')
+echo "Response: $BULK_RESP"
+if [[ "$BULK_RESP" == *"ok\":true"* ]]; then
+    TEST4_STATUS="${GREEN}PASSED${NC}"
+else
+    TEST4_STATUS="${RED}FAILED${NC}"
+fi
+
+# Test 5: Image generation (GPT-2)
+echo -e "\n${BLUE}[Test 5] Testing GPT-2 image generation (Cute baby dragon)...${NC}"
+echo "⏳ Polling for GPT-2 generation, this will take 15-35 seconds..."
+GEN_RESP=$(curl -s -X POST http://127.0.0.1:9225/api/chat \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "Create a cute 3D cartoon baby dragon sitting on a small chest of gold. Directly generate the image now without asking any questions or confirmation."}')
+echo "Response: $GEN_RESP"
+
+# Extract generated image path
+GEN_IMAGE_PATH=$(echo "$GEN_RESP" | grep -o '"images":\["[^"]*' | cut -d'"' -f4)
+if [ -n "$GEN_IMAGE_PATH" ] && [ -f "$GEN_IMAGE_PATH" ]; then
+    TEST5_STATUS="${GREEN}PASSED ($GEN_IMAGE_PATH)${NC}"
+else
+    TEST5_STATUS="${RED}FAILED (Image file not generated/saved)${NC}"
+fi
+
+# Test 6: Image editing (GPT-2 Edit/Vision)
+if [ -n "$GEN_IMAGE_PATH" ] && [ -f "$GEN_IMAGE_PATH" ]; then
+    echo -e "\n${BLUE}[Test 6] Testing GPT-2 image editing (Adding wizard hat)...${NC}"
+    echo "⏳ Uploading source image and polling for edit, this will take 15-35 seconds..."
+    EDIT_RESP=$(curl -s -X POST http://127.0.0.1:9225/api/chat/edit \
+      -F "prompt=Add a small glowing wizard hat to the head of this dragon." \
+      -F "image=@$GEN_IMAGE_PATH")
+    echo "Response: $EDIT_RESP"
+
+    EDIT_IMAGE_PATH=$(echo "$EDIT_RESP" | grep -o '"images":\["[^"]*' | cut -d'"' -f4)
+    if [ -n "$EDIT_IMAGE_PATH" ] && [ -f "$EDIT_IMAGE_PATH" ]; then
+        TEST6_STATUS="${GREEN}PASSED ($EDIT_IMAGE_PATH)${NC}"
+    else
+        TEST6_STATUS="${RED}FAILED (Edited image file not generated/saved)${NC}"
+    fi
+else
+    TEST6_STATUS="${YELLOW}SKIPPED (No source image generated in Test 5)${NC}"
+fi
+
+echo -e "\n${BLUE}==================================================${NC}"
+echo -e "${BLUE}                Test Summary                      ${NC}"
+echo -e "${BLUE}==================================================${NC}"
+echo -e "1. Cookie Status:        $TEST1_STATUS"
+echo -e "2. Basic Chat:           $TEST2_STATUS"
+echo -e "3. Thread Continuity:    $TEST3_STATUS"
+echo -e "4. Bulk Chat:            $TEST4_STATUS"
+echo -e "5. GPT-2 Gen:            $TEST5_STATUS"
+echo -e "6. GPT-2 Image Editing:  $TEST6_STATUS"
+echo -e "${BLUE}==================================================${NC}"
+
+echo -e "\n${GREEN}✅ Tests completed!${NC}\n"

flow-agent/.gitignore

@@ -0,0 +1,15 @@
+*.mp4
+*.avi
+*.mov
+__pycache__/
+*.pyc
+.env
+venv/
+.DS_Store
+sniffed.json
+sniffed_all.json
+media_ids.json
+output/
+chunks/
+*.mp4
+__pycache__/

flow-agent/README.md

@@ -0,0 +1,468 @@
+<div align="center">
+
+# ⚡ Flow Agent
+
+### Generate AI videos & images via HTTP/HTTPS API Server or CLI — no API key, no limits.
+
+**Omni Flash** for cinematic video generation · **Nano Banana 2** for unlimited image creation  
+FastAPI Integration · Auto watermark removal · Reference-based editing · Zero setup.
+
+---
+
+🎬 `T2V` `V2V` `I2V` — Video generation with auto watermark clean *(uses credits)*  
+🖼️ `T2I` `I2I` — Unlimited image generation with reference support *(no credits needed)*  
+🔑 Uses your Google account via Chrome extension — **no API key required**  
+🌐 FastAPI HTTP/HTTPS Server — **perfect for n8n & external automation**
+
+</div>
+
+
+## ✅ Features & Status
+
+| Feature | What it does | Time | Status |
+|---------|-------------|------|--------|
+| **T2V** | Generate video from text prompt | ~44s | ✅ Working |
+| **T2I** | Generate image from text prompt | ~10-30s | ✅ Working |
+| **V2V** | Edit/restyle existing video | ~3min | ✅ Working |
+| **I2I** | Edit image with reference | ~10-30s | ✅ Working |
+| **I2V** | Animate a still image into video | ~44s | ✅ Working |
+| **FL** | First + Last frame video control | ~44s | ✅ Working |
+| **R2V** | Reference-based video generation | ~44s | ✅ Working |
+| **Upload** | Upload video/image to Flow | ~12s | ✅ Working |
+| **Watermark Remove** | Auto-remove Gemini watermark (~1s) | ~1s | ✅ Auto |
+| **Auto-Retry** | Auto-open/refresh Flow tab for token | auto | ✅ Built-in |
+| **API Sniffer** | Discover new endpoints/payloads | - | ✅ Working |
+
+---
+
+## 📋 Prerequisites
+
+| Requirement | Details |
+|-------------|---------|
+| **Python** | 3.9 or higher |
+| **Chrome** | Latest version |
+| **Google Account** | Logged into Flow |
+| **ffmpeg** | Only for V2V merge (optional) |
+
+---
+
+## 🛠️ Installation (Step by Step)
+
+### Step 1: Clone the repo
+
+```bash
+git clone https://github.com/kodelyx/flow-agent.git
+cd flow-agent
+```
+
+### Step 2: Install Python dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+This installs `websockets`, `opencv-python-headless`, and `numpy`.
+
+### Step 3: Install the Chrome Extension
+
+1. Open Chrome browser
+2. Go to `chrome://extensions` in the address bar
+3. Toggle **"Developer mode"** ON (top-right corner)
+4. Click **"Load unpacked"**
+5. Select the `extension/` folder from this repo
+6. You should see the **Flow Agent** extension appear
+
+### Step 4: Open Google Flow
+
+1. Open [labs.google/fx/tools/flow](https://labs.google/fx/tools/flow) in Chrome
+2. Make sure you're **logged into your Google account**
+3. The extension icon should show a **green badge** = connected
+4. The extension auto-opens this tab when needed
+
+> ⚠️ The Flow tab auto-opens when you run a command. No manual tab management needed!
+
+---
+
+## 🚀 Usage
+
+### Text → Video (T2V)
+
+Generate a new video from a text description.
+
+```bash
+# Basic (portrait 9:16, 10 seconds)
+python -m cli.generate "A samurai drawing his katana on a cliff at golden sunset"
+
+# Landscape mode (16:9)
+python -m cli.generate "Eagle soaring over snowy mountains" --aspect landscape
+
+# Custom output file
+python -m cli.generate "A dragon breathing fire" -o dragon.mp4
+
+# Shorter duration (4/6/8/10 seconds)
+python -m cli.generate "Dog playing in the park" --duration 6
+
+# Generate multiple variations
+python -m cli.generate "Cyberpunk city at night" --count 4
+
+# I2V — animate a still image
+python -m cli.generate "Character comes alive" --start photo.png
+
+# FL — First + Last frame (controlled transition)
+python -m cli.generate "Person walks forward" --start start.png --end end.png
+
+# R2V — Reference images (character consistency)
+python -m cli.generate "Character in new scene" --ref char1.png char2.png
+```
+
+**CLI Options:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--output` | `-o` | `omni_output.mp4` | Output filename |
+| `--aspect` | `-a` | `portrait` | `portrait` or `landscape` |
+| `--duration` | `-d` | `10` | `4`, `6`, `8`, or `10` seconds |
+| `--count` | `-c` | `1` | Generate 1-4 videos |
+| `--edit` | `-e` | - | Pass media_id for V2V edit mode |
+| `--start` | `-s` | - | Start frame image (I2V / FL mode) |
+| `--end` | | - | End frame image (use with --start for FL) |
+| `--ref` | `-r` | - | Reference image(s) for R2V mode |
+| `--no-clean` | | - | Skip auto watermark removal |
+
+---
+
+### Text → Image (T2I)
+
+Generate images from a text description.
+
+```bash
+# Basic (portrait 9:16)
+python -m cli.image "A dragon breathing fire in a cyberpunk city"
+
+# Landscape
+python -m cli.image "Mountain sunset" --aspect landscape -o sunset.png
+
+# Square (for logos, icons)
+python -m cli.image "Minimal logo design" --aspect square
+
+# Generate 4 variations
+python -m cli.image "Abstract art" --count 4
+
+# I2I: Edit with reference image
+python -m cli.image "Make it anime style" --ref original.png -o anime.png
+```
+
+**CLI Options:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--output` | `-o` | `output/image.png` | Output filename |
+| `--aspect` | `-a` | `portrait` | `portrait`, `landscape`, `square`, `4x3`, `3x4` |
+| `--count` | `-c` | `1` | Generate 1-4 variations |
+| `--ref` | `-r` | - | Reference image(s) for I2I |
+
+### Upload Video
+
+Upload a local video to Google Flow. Returns a `media_id` needed for V2V editing.
+
+```bash
+# Single video
+python -m cli.upload my_video.mp4
+
+# Batch upload all .mp4 in a folder
+python -m cli.upload chunks/ --batch
+```
+
+The `media_id` is **automatically saved** to `media-id.js`:
+```
+my_video.mp4 : 49f7d936-01e3-41ad-917a-2f9bb6ead00b
+```
+
+---
+
+### Video → Video Edit (V2V)
+
+Apply style changes to an uploaded video (e.g., convert to anime).
+
+```bash
+# Step 1: Upload your video
+python -m cli.upload my_video.mp4
+# → media_id saved to media-id.js
+
+# Step 2: Edit with style prompt
+python -m cli.edit "Transform into vibrant anime style, Studio Ghibli aesthetic" \
+    --media-id 49f7d936-01e3-41ad-917a-2f9bb6ead00b \
+    --video-file my_video.mp4 \
+    --output output_anime/ \
+    --merge
+
+# Without local video file (specify duration manually)
+python -m cli.edit "Make it look cyberpunk neon" \
+    -m MEDIA_ID \
+    --total-seconds 30 \
+    -o output_cyber/
+```
+
+**How it works:** Long videos are automatically split into 10s segments, each processed in parallel, then merged with ffmpeg.
+
+**CLI Options:**
+| Flag | Short | Required | Description |
+|------|-------|----------|-------------|
+| `--media-id` | `-m` | Yes | Flow media ID (from upload) |
+| `--video-file` | `-v` | No | Local file (auto-detects duration/fps) |
+| `--total-seconds` | `-t` | No | Duration if no local file |
+| `--output` | `-o` | No | Output directory (default: `output/`) |
+| `--aspect` | `-a` | No | `portrait` or `landscape` |
+| `--merge` | | No | Merge segments with ffmpeg |
+
+---
+
+### Image → Video (I2V)
+
+Animate a still image into a video. Requires Python scripting (no CLI yet):
+
+```python
+import asyncio
+from omniflash import (
+    ExtensionBridge, upload_image, generate_video_i2v,
+    poll_status, download_video, ASPECTS, DEFAULT_PROJECT,
+)
+
+async def main():
+    # Connect to extension
+    bridge = ExtensionBridge()
+    await bridge.start()
+    await bridge.wait_for_extension(30)
+
+    # Upload your image
+    img_id = await upload_image(bridge, "my_image.png")
+    print(f"Image uploaded: {img_id}")
+
+    # Generate video from image
+    media_ids = await generate_video_i2v(
+        bridge,
+        prompt="The character comes alive, dramatic movement, cinematic",
+        aspect=ASPECTS['portrait'],       # or ASPECTS['landscape']
+        project_id=DEFAULT_PROJECT,
+        image_media_id=img_id,
+        duration=8,                        # 4, 6, 8, or 10 seconds
+    )
+
+    # Wait for video to finish
+    if media_ids:
+        await poll_status(bridge, media_ids[0], DEFAULT_PROJECT)
+        await download_video(bridge, media_ids[0], "output_i2v.mp4")
+
+    await bridge.close()
+
+asyncio.run(main())
+```
+
+---
+
+### API Sniffer
+
+Capture all API requests made by the Flow UI. Useful for discovering new endpoints or debugging.
+
+```bash
+# Start sniffer, then use Flow UI normally
+python -m cli.sniff
+
+# Save captured requests to file
+python -m cli.sniff --save sniffed.json
+```
+
+See [SNIFFING.md](SNIFFING.md) for the full API discovery guide.
+
+---
+
+## 🌐 HTTP/HTTPS API Server (for n8n & external integrations)
+
+A FastAPI-based API server is included to trigger all Flow Agent features remotely (e.g., from n8n HTTP Request nodes, custom webhooks, or automation workflows).
+
+### Start the API Server
+
+Run the server from the project directory:
+```bash
+# Standard HTTP (defaults to port 8000)
+venv/bin/python -m cli.api --host 0.0.0.0 --port 8000
+
+# Optional HTTPS (auto-generates self-signed SSL certificates)
+venv/bin/python -m cli.api --host 0.0.0.0 --port 8443 --ssl
+```
+
+### Core API Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| **GET** | `/health` | Check Extension Bridge health and token status. |
+| **POST** | `/generate/video` | T2V, I2V, FL, R2V video generation. Supports query `?download=true` to stream the binary `.mp4` file. |
+| **POST** | `/generate/image` | T2I, I2I image generation. Supports `?download=true` to stream the binary `.png` file. |
+| **POST** | `/upload/image` | Upload an image to Flow (via file upload or local file path). |
+| **POST** | `/upload/video` | Upload a video to Flow (via file upload or local file path). |
+| **POST** | `/edit/video` | V2V video editing (restyling segment duration). |
+| **GET** | `/download/{filename}` | Download generated image/video files from the `output/` folder. |
+
+### Verify with Integration Tests
+
+A comprehensive integration test script is provided to verify all endpoints:
+```bash
+venv/bin/python test_api.py
+```
+
+See [error.md](error.md) for detailed troubleshooting instructions if you encounter port conflicts or proxy network issues.
+
+---
+
+## 🐍 Python API (for developers)
+
+Use the `omniflash` package directly in your own scripts:
+
+```python
+from omniflash import (
+    ExtensionBridge,          # WebSocket bridge to Chrome extension
+    generate_video,           # T2V: text → video
+    edit_video,               # V2V: video → video
+    upload_image,             # Upload image → get media_id
+    generate_video_i2v,       # I2V: image → video
+    poll_status,              # Poll until video is ready
+    download_video,           # Download finished video
+    ASPECTS,                  # {'portrait': '...', 'landscape': '...'}
+    DEFAULT_PROJECT,          # Your default project ID
+)
+from omniflash.upload import upload_video  # Upload video file
+from omniflash import media_store          # Read/write media-id.js
+
+# media_store examples:
+media_store.save("video.mp4", "uuid-here")   # Save entry
+mid = media_store.get("video.mp4")            # Get media_id
+all_entries = media_store.read_entries()       # Get all entries
+```
+
+> **Backward compatible:** `from omni import ExtensionBridge, generate_video, ...` still works.
+
+---
+
+## 📁 Project Structure
+
+```
+flow-agent/
+├── omniflash/                  # Core Python package
+│   ├── __init__.py             # Public API exports
+│   ├── bridge.py               # ExtensionBridge (WS + HTTP + auto-retry)
+│   ├── config.py               # All config hardcoded here
+│   ├── media_store.py          # media-id.js read/write
+│   ├── upload.py               # Video upload (GCS resumable)
+│   ├── watermark.py            # Auto watermark removal (embedded assets)
+│   └── generators/             # API functions
+│       ├── common.py           # poll_status, download_video
+│       ├── t2v.py              # Text → Video
+│       ├── t2i.py              # Text → Image + I2I
+│       ├── v2v.py              # Video → Video (edit)
+│       └── i2v.py              # Image → Video + upload_image
+├── cli/                        # CLI entry points
+│   ├── generate.py             # python -m cli.generate
+│   ├── image.py                # python -m cli.image
+│   ├── upload.py               # python -m cli.upload
+│   ├── edit.py                 # python -m cli.edit
+│   └── sniff.py                # python -m cli.sniff
+├── extension/                  # Chrome extension
+│   ├── manifest.json           # Extension manifest
+│   ├── background.js           # WS client, API proxy
+│   ├── content.js              # Page ↔ background bridge
+│   └── injected.js             # Fetch interceptor, reCAPTCHA
+├── omni.py                     # Backward-compatible wrapper
+├── .gitignore                  # Git ignore rules
+├── media-id.js                 # Auto-updated filename → media_id
+├── requirements.txt            # Python dependencies
+├── SNIFFING.md                 # API discovery guide
+└── README.md
+```
+
+---
+
+## ⚙️ How It Works
+
+```
+┌─────────────────────────────────┐
+│  Your Terminal / Python Script  │
+│  python -m cli.generate "..."   │
+└──────────┬──────────────────────┘
+           │ import omniflash
+           ▼
+┌─────────────────────────────────┐
+│  omniflash package              │
+│  ExtensionBridge (WS + HTTP)    │
+└──────────┬──────────────────────┘
+           │ WebSocket (:9222)
+           │ HTTP callback (:8100)
+           ▼
+┌─────────────────────────────────┐
+│  Chrome Extension (Flow Agent) │
+│  Auth token + reCAPTCHA solving │
+└──────────┬──────────────────────┘
+           │ HTTPS (browser cookies)
+           ▼
+┌─────────────────────────────────┐
+│  Google Omni API (aisandbox)    │
+│  Video generation / editing     │
+└─────────────────────────────────┘
+```
+
+1. Python starts a WebSocket server + HTTP callback server
+2. Chrome extension auto-connects and provides authentication
+3. Script sends API requests through the extension
+4. Extension solves reCAPTCHA and proxies with browser cookies
+5. Script polls for completion, then downloads the result
+
+---
+
+## 🎯 Models & Endpoints
+
+| Model | Key | Duration | Type |
+|-------|-----|----------|------|
+| Omni Flash T2V 4s | `abra_t2v_4s` | 4 sec | Text → Video |
+| Omni Flash T2V 6s | `abra_t2v_6s` | 6 sec | Text → Video |
+| Omni Flash T2V 8s | `abra_t2v_8s` | 8 sec | Text → Video |
+| Omni Flash T2V 10s | `abra_t2v_10s` | 10 sec | Text → Video |
+| Omni Flash Edit | `abra_edit` | 10 sec | Video → Video |
+
+| Endpoint | Path |
+|----------|------|
+| T2V | `/v1/video:batchAsyncGenerateVideoText` |
+| I2V | `/v1/video:batchAsyncGenerateVideoStartImage` |
+| V2V Edit | `/v1/video:batchAsyncGenerateVideoEditVideo` |
+| Upload Image | `/v1/flow/uploadImage` |
+| Poll Status | `/v1/video:batchCheckAsyncVideoGenerationStatus` |
+| Get Media | `/v1/video/media/{media_id}` |
+
+---
+
+## 🔧 Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| Extension not connecting | Make sure Flow tab is open and you're logged in |
+| `Address already in use` | Another script is using port 9222/8100. Kill it first |
+| `TIMEOUT` error | Extension may have disconnected. Reload Flow tab |
+| `reCAPTCHA failed` | Reload Flow tab, wait a few seconds, try again |
+| `No media in response` | Check your prompt. Some prompts get blocked |
+| `curl failed` | Upload too large or network issue. Retry |
+| Video quality poor | Use longer duration (10s) and detailed prompts |
+| V2V merge fails | Install ffmpeg: `brew install ffmpeg` |
+
+---
+
+## ⚠️ Important Notes
+
+- **Flow tab auto-opens** — no manual tab management needed
+- Uses your Google account's **free Flow credits** (check remaining in Flow UI)
+- Extension auto-reconnects and auto-retries (3 attempts)
+- **Watermark auto-removed** on every generated video (~1s)
+- `media-id.js` auto-updates on every upload (video or image)
+- All generated videos save to the `output/` directory by default
+- Old `from omni import ...` syntax still works (backward compatible)
+
+---
+
+## 📄 License
+
+MIT

flow-agent/SNIFFING.md

@@ -0,0 +1,205 @@
+# 🔍 API Sniffing Guide
+
+How to discover new Google Flow API endpoints using the Chrome extension's built-in request sniffer.
+
+## How It Works
+
+```
+Flow UI (browser)
+    ↓ user clicks "Generate" / "Upload" etc.
+    ↓
+fetch() call to aisandbox-pa.googleapis.com
+    ↓ intercepted by injected.js (monkey-patched fetch)
+    ↓
+postMessage → content.js → background.js
+    ↓
+HTTP POST → http://127.0.0.1:8100/api/ext/callback
+    ↓
+Your sniff server logs the URL + payload
+```
+
+The extension's `injected.js` monkey-patches `window.fetch` to intercept ALL outgoing requests to `aisandbox-pa.googleapis.com`. Every request's URL, method, and body are forwarded to your local server.
+
+## Quick Start
+
+### 1. Start the Sniff Server
+
+```python
+python sniff.py
+```
+
+This starts:
+- WebSocket server on `ws://127.0.0.1:9222` (extension connects here)
+- HTTP server on `http://127.0.0.1:8100` (receives sniffed data)
+
+### 2. Open Flow UI
+
+Go to [labs.google/fx/tools/flow](https://labs.google/fx/tools/flow) in Chrome.
+The extension will auto-connect to your sniff server.
+
+### 3. Perform the Action
+
+Do whatever you want to discover the API for:
+- Upload an image/video
+- Generate a video
+- Change settings
+- Click any button
+
+### 4. Read the Logs
+
+The sniff server prints every intercepted request:
+```
+🔍 SNIFFED: https://aisandbox-pa.googleapis.com/v1/video:batchAsyncGenerateVideoText
+   Method: POST
+   Payload: {"mediaGenerationContext":{"batchId":"..."},"clientContext":{...},"requests":[...]}
+```
+
+## Sniff Server Code
+
+Save this as `sniff.py`:
+
+```python
+#!/usr/bin/env python3
+"""Sniff server — captures all Flow UI API requests."""
+
+import asyncio, json, websockets, logging
+from http.server import HTTPServer, BaseHTTPRequestHandler
+import threading
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s', datefmt='%H:%M:%S')
+log = logging.getLogger('sniff')
+
+# Store all sniffed requests
+all_requests = []
+
+class Handler(BaseHTTPRequestHandler):
+    def do_POST(self):
+        length = int(self.headers.get('Content-Length', 0))
+        body = json.loads(self.rfile.read(length)) if length else {}
+
+        if body.get('type') == 'sniffed_video_request':
+            url = body.get('url', '')
+            method = body.get('method', '?')
+            payload = body.get('payload', '')
+
+            log.info('🔍 %s %s', method, url)
+            if payload:
+                log.info('   %s', str(payload)[:1000])
+
+            all_requests.append({
+                'url': url,
+                'method': method,
+                'payload': payload,
+                'timestamp': body.get('timestamp'),
+            })
+
+        self.send_response(200)
+        self.send_header('Content-Type', 'application/json')
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.end_headers()
+        self.wfile.write(b'{"ok":true}')
+
+    def do_OPTIONS(self):
+        self.send_response(200)
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.send_header('Access-Control-Allow-Methods', 'POST')
+        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+        self.end_headers()
+
+    def log_message(self, *a): pass
+
+# Start HTTP server
+srv = HTTPServer(('127.0.0.1', 8100), Handler)
+threading.Thread(target=srv.serve_forever, daemon=True).start()
+log.info('HTTP callback on :8100')
+
+async def on_connect(ws):
+    log.info('✅ Extension connected!')
+    async for raw in ws:
+        data = json.loads(raw)
+        if data.get('type') == 'token_captured':
+            log.info('🔑 Token captured')
+
+async def main():
+    async with websockets.serve(on_connect, '127.0.0.1', 9222):
+        log.info('⚡ WS server on :9222')
+        log.info('👉 Open Flow UI and perform any action...')
+        await asyncio.Future()
+
+asyncio.run(main())
+```
+
+## What Gets Captured
+
+| Action in Flow UI | API Endpoint |
+|-------------------|-------------|
+| Generate video (T2V) | `/v1/video:batchAsyncGenerateVideoText` |
+| Generate video (I2V) | `/v1/video:batchAsyncGenerateVideoStartImage` |
+| Generate video (Edit) | `/v1/video:batchAsyncGenerateVideoEditVideo` |
+| Poll video status | `/v1/video:batchCheckAsyncVideoGenerationStatus` |
+| Upload image | `/v1/flow/uploadImage` |
+| Generate image | `/v1/projects/{id}/flowMedia:batchGenerateImages` |
+| Get credits | `/v1/credits` |
+| Get media | `/v1/media/{media_id}` |
+| Upscale video | `/v1/video:batchAsyncGenerateVideoUpsampleVideo` |
+
+## How to Find New Endpoints
+
+### Example: Finding Video Upload
+
+1. Start `sniff.py`
+2. Open Flow UI
+3. Drag & drop a video file into Flow
+4. Check logs — you'll see the upload URL and payload format
+5. Add the new endpoint to `models.json`
+
+### Example: Finding Model Keys
+
+1. Start `sniff.py`  
+2. Open Flow UI
+3. Select different model (e.g., Omni Flash 4s)
+4. Click Generate
+5. Check logs — look for `videoModelKey` in the payload
+
+```json
+"requests": [{
+    "videoModelKey": "abra_t2v_4s",   ← this is what you need
+    ...
+}]
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│  injected.js (MAIN world)                   │
+│  - Monkey-patches window.fetch              │
+│  - Captures URL + body of every request     │
+│  - Posts to content.js via postMessage       │
+└──────────────────┬──────────────────────────┘
+                   │ postMessage
+┌──────────────────▼──────────────────────────┐
+│  content.js (ISOLATED world)                │
+│  - Listens for __FLOWKIT_SNIFF__ messages    │
+│  - Forwards to background.js                │
+└──────────────────┬──────────────────────────┘
+                   │ chrome.runtime.sendMessage
+┌──────────────────▼──────────────────────────┐
+│  background.js (Service Worker)             │
+│  - Receives SNIFFED_AISANDBOX_REQUEST       │
+│  - POSTs to http://127.0.0.1:8100/callback  │
+└──────────────────┬──────────────────────────┘
+                   │ HTTP POST
+┌──────────────────▼──────────────────────────┐
+│  sniff.py (Your server)                     │
+│  - Logs every request                       │
+│  - Saves URL + method + payload             │
+└─────────────────────────────────────────────┘
+```
+
+## Tips
+
+- **Filter by keyword**: Modify the sniff server to only log URLs containing specific words (e.g., `upload`, `video`, `generate`)
+- **Save to file**: Add `json.dump(all_requests, open('sniffed.json', 'w'))` to save all captured requests
+- **Compare payloads**: Run the same action with different settings and diff the payloads to find which fields control what
+- **Telemetry noise**: Ignore URLs containing `batchLog`, `fetchUserRecommendations`, `frontendEvents` — these are analytics, not API calls

flow-agent/cli/api.py

@@ -0,0 +1,617 @@
+#!/usr/bin/env python3
+"""FastAPI Server for Flow Agent — expose CLI functionality via HTTP/HTTPS.
+
+Allows n8n and other remote systems to trigger video/image generation and upload assets.
+"""
+
+import os
+import sys
+import uuid
+import time
+import shutil
+import base64
+import logging
+import asyncio
+from typing import List, Optional
+from contextlib import asynccontextmanager
+
+# Add parent dir to sys.path so omniflash can be imported
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException, Query
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+
+from omniflash import (
+    ExtensionBridge, generate_video, edit_video,
+    poll_status, download_video, ASPECTS, DEFAULT_PROJECT,
+)
+from omniflash.generators.i2v import upload_image, generate_video_i2v, generate_video_fl, generate_video_r2v
+from omniflash.generators.t2i import generate_image, download_image, IMAGE_ASPECTS
+from omniflash.upload import upload_video
+
+# Setup logging
+log = logging.getLogger("omniflash.api")
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", datefmt="%H:%M:%S")
+
+# Ensure required directories exist
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+OUTPUT_DIR = os.path.join(ROOT_DIR, "output")
+TEMP_DIR = os.path.join(OUTPUT_DIR, ".temp")
+
+def ensure_temp_dir():
+    os.makedirs(TEMP_DIR, exist_ok=True)
+
+def cleanup_temp_dir():
+    try:
+        if os.path.exists(TEMP_DIR) and not os.listdir(TEMP_DIR):
+            os.rmdir(TEMP_DIR)
+    except Exception:
+        pass
+
+# Global ExtensionBridge instance
+bridge: Optional[ExtensionBridge] = None
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global bridge
+    log.info("🚀 Starting Flow Agent Extension Bridge...")
+    bridge = ExtensionBridge()
+    await bridge.start()
+    
+    # Run extension connection in background so the API server starts immediately
+    asyncio.create_task(bridge.wait_for_extension(timeout=30))
+    
+    yield
+    
+    log.info("🔌 Closing Flow Agent Extension Bridge...")
+    if bridge:
+        await bridge.close()
+    cleanup_temp_dir()
+
+app = FastAPI(
+    title="Flow Agent API",
+    description="API Server to trigger Google Flow AI video and image generation",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Enable CORS for convenience
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Helper function to check/reconnect the bridge
+async def get_active_bridge() -> ExtensionBridge:
+    global bridge
+    if not bridge:
+        raise HTTPException(status_code=503, detail="Extension bridge is not initialized")
+    
+    # Try a quick health check
+    is_healthy = await bridge.health_check()
+    if not is_healthy:
+        log.info("🔄 Bridge health check failed. Re-waiting for extension connection...")
+        # Attempt to reconnect / grab flowKey
+        connected = await bridge.wait_for_extension(timeout=10, max_retries=1)
+        if not connected:
+            raise HTTPException(
+                status_code=503,
+                detail="Google Flow extension is not connected or unauthorized. Make sure Google Flow tab is open in Chrome."
+            )
+    return bridge
+
+# Helper to process image inputs (local path, media_id, or base64 data)
+async def resolve_image_input(active_bridge: ExtensionBridge, path_or_id_or_b64: str, project_id: str) -> str:
+    if not path_or_id_or_b64:
+        return ""
+    
+    # Case 1: Base64 data (e.g. data:image/png;base64,... or raw base64)
+    if path_or_id_or_b64.startswith("data:") or len(path_or_id_or_b64) > 500:
+        try:
+            if "," in path_or_id_or_b64:
+                base64_data = path_or_id_or_b64.split(",", 1)[1]
+            else:
+                base64_data = path_or_id_or_b64
+            
+            img_bytes = base64.b64decode(base64_data)
+            temp_filename = f"b64_{uuid.uuid4().hex}.png"
+            ensure_temp_dir()
+            temp_path = os.path.join(TEMP_DIR, temp_filename)
+            with open(temp_path, "wb") as f:
+                f.write(img_bytes)
+            
+            mid = await upload_image(active_bridge, temp_path, project_id)
+            try:
+                os.remove(temp_path)
+            except OSError:
+                pass
+            cleanup_temp_dir()
+            
+            if not mid:
+                raise HTTPException(status_code=400, detail="Failed to upload base64 image reference")
+            return mid
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Failed parsing base64 image: {str(e)}")
+            
+    # Case 2: Local file path
+    if os.path.exists(path_or_id_or_b64):
+        mid = await upload_image(active_bridge, path_or_id_or_b64, project_id)
+        if not mid:
+            raise HTTPException(status_code=400, detail=f"Failed to upload local image path: {path_or_id_or_b64}")
+        return mid
+        
+    # Case 3: Already a Media ID (UUID or similar format)
+    return path_or_id_or_b64
+
+
+# Request Models
+class VideoGenerationRequest(BaseModel):
+    prompt: str = Field(..., description="Text prompt for video generation")
+    aspect: str = Field("portrait", description="Aspect ratio: 'portrait' or 'landscape'")
+    duration: int = Field(10, description="Duration in seconds: 4, 6, 8, or 10")
+    count: int = Field(1, description="Number of variations (1-4)")
+    project_id: str = Field(DEFAULT_PROJECT, description="Flow project ID")
+    start: Optional[str] = Field(None, description="Start frame image (file path, media_id, or base64)")
+    end: Optional[str] = Field(None, description="End frame image (use with start for FL mode)")
+    ref: Optional[List[str]] = Field(None, description="Reference image(s) (file path, media_id, or base64)")
+    edit: Optional[str] = Field(None, description="Flow video media_id for video editing (V2V)")
+    no_clean: bool = Field(False, description="Skip watermark removal")
+
+
+class ImageGenerationRequest(BaseModel):
+    prompt: str = Field(..., description="Text prompt for image generation")
+    aspect: str = Field("portrait", description="Aspect ratio: 'portrait', 'landscape', 'square', '4x3', '3x4'")
+    count: int = Field(1, description="Number of variations (1-4)")
+    ref: Optional[List[str]] = Field(None, description="Reference image(s) (file path, media_id, or base64)")
+    project_id: str = Field(DEFAULT_PROJECT, description="Flow project ID")
+
+
+class VideoEditRequest(BaseModel):
+    prompt: str = Field(..., description="Restyle/edit text prompt")
+    video_media_id: str = Field(..., description="Original video media_id")
+    aspect: str = Field("portrait", description="Aspect ratio: 'portrait' or 'landscape'")
+    fps: int = Field(24, description="FPS of source video")
+    duration: int = Field(10, description="Duration of segment to edit")
+    start_frame: int = Field(0, description="Start frame index")
+    end_frame: Optional[int] = Field(None, description="End frame index")
+    project_id: str = Field(DEFAULT_PROJECT, description="Flow project ID")
+    download: bool = Field(False, description="Directly download binary video stream")
+
+
+# API Routes
+
+@app.get("/health")
+async def health():
+    """Check API server connection and Chrome extension authorization."""
+    global bridge
+    if not bridge:
+        return {"status": "starting", "extension_connected": False, "has_flow_key": False}
+    
+    is_healthy = await bridge.health_check()
+    return {
+        "status": "healthy" if is_healthy else "disconnected_or_unauthorized",
+        "extension_connected": bridge._ws is not None,
+        "has_flow_key": bridge._flow_key is not None
+    }
+
+
+@app.post("/upload/image")
+async def api_upload_image(
+    file: Optional[UploadFile] = File(None),
+    path: Optional[str] = Form(None),
+    project_id: str = Form(DEFAULT_PROJECT)
+):
+    """Upload an image to Google Flow. Accepts multipart file upload or local file path."""
+    active_bridge = await get_active_bridge()
+    
+    temp_path = None
+    if file:
+        temp_filename = f"upload_{uuid.uuid4().hex}_{file.filename}"
+        ensure_temp_dir()
+        temp_path = os.path.join(TEMP_DIR, temp_filename)
+        with open(temp_path, "wb") as f:
+            shutil.copyfileobj(file.file, f)
+        upload_path = temp_path
+    elif path:
+        if not os.path.exists(path):
+            raise HTTPException(status_code=404, detail=f"Local file not found: {path}")
+        upload_path = path
+    else:
+        raise HTTPException(status_code=400, detail="Must provide 'file' (multipart) or 'path' (form parameter)")
+    
+    try:
+        media_id = await upload_image(active_bridge, upload_path, project_id)
+        if not media_id:
+            raise HTTPException(status_code=500, detail="Flow image upload failed")
+        return {"success": True, "media_id": media_id}
+    finally:
+        if temp_path and os.path.exists(temp_path):
+            try:
+                os.remove(temp_path)
+            except OSError:
+                pass
+        cleanup_temp_dir()
+
+
+@app.post("/upload/video")
+async def api_upload_video(
+    file: Optional[UploadFile] = File(None),
+    path: Optional[str] = Form(None),
+    project_id: str = Form(DEFAULT_PROJECT)
+):
+    """Upload a video to Google Flow. Accepts multipart file upload or local file path."""
+    active_bridge = await get_active_bridge()
+    
+    temp_path = None
+    if file:
+        temp_filename = f"upload_{uuid.uuid4().hex}_{file.filename}"
+        ensure_temp_dir()
+        temp_path = os.path.join(TEMP_DIR, temp_filename)
+        with open(temp_path, "wb") as f:
+            shutil.copyfileobj(file.file, f)
+        upload_path = temp_path
+    elif path:
+        if not os.path.exists(path):
+            raise HTTPException(status_code=404, detail=f"Local file not found: {path}")
+        upload_path = path
+    else:
+        raise HTTPException(status_code=400, detail="Must provide 'file' (multipart) or 'path' (form parameter)")
+    
+    try:
+        result = await upload_video(upload_path, project_id, active_bridge)
+        media_id = result.get("mediaId") or result.get("name") or result.get("id")
+        if not media_id and isinstance(result.get("media"), dict):
+            media_id = result["media"].get("name") or result["media"].get("mediaId")
+            
+        if not media_id:
+            raise HTTPException(status_code=500, detail=f"Flow video upload failed: {result}")
+        return {"success": True, "media_id": media_id, "data": result}
+    finally:
+        if temp_path and os.path.exists(temp_path):
+            try:
+                os.remove(temp_path)
+            except OSError:
+                pass
+        cleanup_temp_dir()
+
+
+@app.post("/generate/video")
+async def api_generate_video(req: VideoGenerationRequest, download: bool = Query(False)):
+    """Generate or edit video via text prompt and optional references (T2V, I2V, FL, R2V, V2V)."""
+    active_bridge = await get_active_bridge()
+    aspect = ASPECTS.get(req.aspect, "VIDEO_ASPECT_RATIO_PORTRAIT")
+    
+    # 1. Resolve starting image (I2V / FL)
+    start_id = None
+    if req.start:
+        start_id = await resolve_image_input(active_bridge, req.start, req.project_id)
+        
+    # 2. Resolve end image (FL)
+    end_id = None
+    if req.end:
+        end_id = await resolve_image_input(active_bridge, req.end, req.project_id)
+        
+    # 3. Resolve reference images (R2V)
+    ref_ids = []
+    if req.ref:
+        for r in req.ref:
+            mid = await resolve_image_input(active_bridge, r, req.project_id)
+            if mid:
+                ref_ids.append(mid)
+                
+    # 4. Trigger generation
+    media_ids = None
+    if start_id and end_id:
+        media_ids = await generate_video_fl(
+            active_bridge, req.prompt, aspect, req.project_id,
+            start_image_id=start_id, end_image_id=end_id, duration=req.duration
+        )
+    elif start_id:
+        media_ids = await generate_video_i2v(
+            active_bridge, req.prompt, aspect, req.project_id,
+            image_media_id=start_id, duration=req.duration
+        )
+    elif ref_ids:
+        media_ids = await generate_video_r2v(
+            active_bridge, req.prompt, aspect, req.project_id,
+            ref_media_ids=ref_ids, duration=req.duration
+        )
+    elif req.edit:
+        media_ids = await edit_video(
+            active_bridge, req.prompt, aspect, req.project_id,
+            video_media_id=req.edit, duration=req.duration
+        )
+    else:
+        media_ids = await generate_video(
+            active_bridge, req.prompt, aspect, req.project_id,
+            duration=req.duration, count=req.count
+        )
+        
+    if not media_ids:
+        raise HTTPException(status_code=500, detail="Failed to initiate video generation")
+        
+    outputs = []
+    timestamp = int(time.time())
+    
+    # 5. Poll and Download
+    for i, media_id in enumerate(media_ids):
+        log.info(f"Polling video [{i+1}/{len(media_ids)}] ID: {media_id}")
+        if not await poll_status(active_bridge, media_id, req.project_id):
+            log.error(f"Polling failed for media ID: {media_id}")
+            continue
+            
+        unique_id = uuid.uuid4().hex[:6]
+        filename = f"omni_{timestamp}_{unique_id}_{i+1}.mp4"
+        out_path = os.path.join(OUTPUT_DIR, filename)
+        ensure_temp_dir()
+        temp_path = os.path.join(TEMP_DIR, filename)
+        
+        if await download_video(active_bridge, media_id, temp_path):
+            if not req.no_clean:
+                try:
+                    from omniflash.watermark import remove_watermark_video
+                    remove_watermark_video(temp_path, out_path)
+                    try:
+                        os.remove(temp_path)
+                    except OSError:
+                        pass
+                except Exception as e:
+                    log.warning(f"Watermark removal failed: {e}. Fallback to raw video.")
+                    os.replace(temp_path, out_path)
+            else:
+                os.replace(temp_path, out_path)
+                
+            outputs.append({
+                "media_id": media_id,
+                "filename": filename,
+                "local_path": out_path,
+                "download_url": f"/download/{filename}"
+            })
+            
+    cleanup_temp_dir()
+    if not outputs:
+        raise HTTPException(status_code=500, detail="Failed to download generated video(s)")
+        
+    # Return binary directly if requested and single file
+    if download and len(outputs) == 1:
+        return FileResponse(
+            path=outputs[0]["local_path"],
+            filename=outputs[0]["filename"],
+            media_type="video/mp4"
+        )
+        
+    return {
+        "success": True,
+        "outputs": outputs
+    }
+
+
+@app.post("/generate/image")
+async def api_generate_image(req: ImageGenerationRequest, download: bool = Query(False)):
+    """Generate image using text prompt and optional reference images (T2I, I2I)."""
+    active_bridge = await get_active_bridge()
+    aspect = req.aspect
+    
+    # Resolve reference images if any
+    ref_ids = []
+    if req.ref:
+        for r in req.ref:
+            mid = await resolve_image_input(active_bridge, r, req.project_id)
+            if mid:
+                ref_ids.append(mid)
+                
+    results = await generate_image(
+        active_bridge, req.prompt, aspect, req.project_id,
+        count=req.count, ref_media_ids=ref_ids or None
+    )
+    
+    if not results:
+        raise HTTPException(status_code=500, detail="Failed to generate image")
+        
+    outputs = []
+    timestamp = int(time.time())
+    
+    for i, r in enumerate(results):
+        url = r.get("image_url")
+        media_id = r.get("media_id")
+        if not url:
+            continue
+            
+        unique_id = uuid.uuid4().hex[:6]
+        filename = f"img_{timestamp}_{unique_id}_{i+1}.png"
+        out_path = os.path.join(OUTPUT_DIR, filename)
+        
+        download_success = await download_image(active_bridge, url, out_path)
+        
+        outputs.append({
+            "media_id": media_id,
+            "filename": filename,
+            "local_path": out_path if download_success else None,
+            "download_url": f"/download/{filename}" if download_success else None,
+            "remote_url": url,
+            "downloaded": download_success
+        })
+        
+    # Return binary directly if requested, single image, and it was successfully downloaded
+    if download and len(outputs) == 1 and outputs[0]["downloaded"]:
+        return FileResponse(
+            path=outputs[0]["local_path"],
+            filename=outputs[0]["filename"],
+            media_type="image/png"
+        )
+        
+    return {
+        "success": True,
+        "outputs": outputs
+    }
+
+
+@app.post("/edit/video")
+async def api_edit_video(req: VideoEditRequest):
+    """Submit V2V edit request."""
+    active_bridge = await get_active_bridge()
+    aspect = ASPECTS.get(req.aspect, "VIDEO_ASPECT_RATIO_PORTRAIT")
+    
+    media_ids = await edit_video(
+        active_bridge, req.prompt, aspect, req.project_id,
+        video_media_id=req.video_media_id, fps=req.fps,
+        duration=req.duration, start_frame=req.start_frame,
+        end_frame=req.end_frame
+    )
+    
+    if not media_ids:
+        raise HTTPException(status_code=500, detail="Failed to submit V2V edit request")
+        
+    outputs = []
+    timestamp = int(time.time())
+    
+    for i, media_id in enumerate(media_ids):
+        log.info(f"Polling edited video [{i+1}/{len(media_ids)}] ID: {media_id}")
+        if not await poll_status(active_bridge, media_id, req.project_id):
+            continue
+            
+        unique_id = uuid.uuid4().hex[:6]
+        filename = f"edit_{timestamp}_{unique_id}_{i+1}.mp4"
+        out_path = os.path.join(OUTPUT_DIR, filename)
+        ensure_temp_dir()
+        temp_path = os.path.join(TEMP_DIR, filename)
+        
+        if await download_video(active_bridge, media_id, temp_path):
+            # V2V edited segments might also have watermarks
+            try:
+                from omniflash.watermark import remove_watermark_video
+                remove_watermark_video(temp_path, out_path)
+                try:
+                    os.remove(temp_path)
+                except OSError:
+                    pass
+            except Exception as e:
+                log.warning(f"Watermark removal failed: {e}. Fallback to raw video.")
+                os.replace(temp_path, out_path)
+                
+            outputs.append({
+                "media_id": media_id,
+                "filename": filename,
+                "local_path": out_path,
+                "download_url": f"/download/{filename}"
+            })
+            
+    cleanup_temp_dir()
+    if not outputs:
+        raise HTTPException(status_code=500, detail="Failed to download edited video(s)")
+        
+    if req.download and len(outputs) == 1:
+        return FileResponse(
+            path=outputs[0]["local_path"],
+            filename=outputs[0]["filename"],
+            media_type="video/mp4"
+        )
+        
+    return {
+        "success": True,
+        "outputs": outputs
+    }
+
+
+@app.get("/download/{filename}")
+async def api_download_file(filename: str):
+    """Download generated assets from output folder."""
+    file_path = os.path.join(OUTPUT_DIR, filename)
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="Requested file not found")
+        
+    # Standardize content types
+    media_type = "application/octet-stream"
+    if filename.endswith(".mp4"):
+        media_type = "video/mp4"
+    elif filename.endswith(".png"):
+        media_type = "image/png"
+    elif filename.endswith(".jpg") or filename.endswith(".jpeg"):
+        media_type = "image/jpeg"
+        
+    return FileResponse(path=file_path, filename=filename, media_type=media_type)
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="Flow Agent API Server")
+    parser.add_argument("--host", default="127.0.0.1", help="Host address")
+    parser.add_argument("--port", type=int, default=8000, help="Port to run on")
+    parser.add_argument("--ssl", action="store_true", help="Enable self-signed SSL certificate")
+    parser.add_argument("--ssl-certfile", help="SSL certificate file path")
+    parser.add_argument("--ssl-keyfile", help="SSL private key file path")
+    args = parser.parse_args()
+
+    ssl_keyfile = args.ssl_keyfile
+    ssl_certfile = args.ssl_certfile
+
+    if args.ssl and not (ssl_keyfile and ssl_certfile):
+        try:
+            from cryptography import x509
+            from cryptography.x509.oid import NameOID
+            from cryptography.hazmat.primitives import hashes
+            from cryptography.hazmat.primitives.asymmetric import rsa
+            from cryptography.hazmat.primitives import serialization
+            import datetime
+
+            # Generate RSA key
+            key = rsa.generate_private_key(
+                public_exponent=65537,
+                key_size=2048,
+            )
+            
+            # Create self-signed cert info
+            subject = issuer = x509.Name([
+                x509.NameAttribute(NameOID.COMMON_NAME, u"localhost"),
+            ])
+            cert = x509.CertificateBuilder().subject_name(
+                subject
+            ).issuer_name(
+                issuer
+            ).public_key(
+                key.public_key()
+            ).serial_number(
+                x509.random_serial_number()
+            ).not_valid_before(
+                datetime.datetime.utcnow()
+            ).not_valid_after(
+                datetime.datetime.utcnow() + datetime.timedelta(days=365)
+            ).add_extension(
+                x509.SubjectAlternativeName([x509.DNSName(u"localhost")]),
+                critical=False,
+            ).sign(key, hashes.SHA256())
+
+            ssl_dir = os.path.join(OUTPUT_DIR, ".ssl")
+            os.makedirs(ssl_dir, exist_ok=True)
+            ssl_keyfile = os.path.join(ssl_dir, "key.pem")
+            ssl_certfile = os.path.join(ssl_dir, "cert.pem")
+
+            with open(ssl_keyfile, "wb") as f:
+                f.write(key.private_bytes(
+                    encoding=serialization.Encoding.PEM,
+                    format=serialization.PrivateFormat.TraditionalOpenSSL,
+                    encryption_algorithm=serialization.NoEncryption(),
+                ))
+            with open(ssl_certfile, "wb") as f:
+                f.write(cert.public_bytes(serialization.Encoding.PEM))
+
+            log.info(f"🔒 Generated temporary self-signed SSL certificate in {ssl_dir}")
+        except ImportError:
+            log.warning("⚠️ cryptography package not found. Cannot auto-generate self-signed SSL cert.")
+            log.warning("   Please install it: pip install cryptography")
+            log.warning("   Falling back to standard HTTP.")
+            args.ssl = False
+
+    import uvicorn
+    uvicorn.run(
+        "cli.api:app",
+        host=args.host,
+        port=args.port,
+        ssl_keyfile=ssl_keyfile if args.ssl or (args.ssl_keyfile and args.ssl_keyfile) else None,
+        ssl_certfile=ssl_certfile if args.ssl or (args.ssl_keyfile and args.ssl_keyfile) else None,
+    )

flow-agent/cli/edit.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""CLI — Full video editor (V2V with segmentation + merge).
+
+Usage:
+    python -m cli.edit "Make it anime style" -m MEDIA_ID -v video.mp4
+    python -m cli.edit "Cyberpunk neon" -m MEDIA_ID --total-seconds 45 -o output/
+"""
+
+import argparse
+import asyncio
+import logging
+import os
+import subprocess
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from omniflash import ExtensionBridge, poll_status, download_video, ASPECTS, DEFAULT_PROJECT
+from omniflash.generators.v2v import edit_video
+from omniflash.generators.common import build_client_context, build_generation_context
+from omniflash.config import ENDPOINTS, CLIENT_CTX, FPS, SEGMENT_DURATION
+
+import random
+
+log = logging.getLogger("cli.edit")
+
+
+def get_video_duration(video_path):
+    """Get video duration in seconds using ffprobe."""
+    try:
+        r = subprocess.run(
+            ["ffprobe", "-v", "quiet", "-show_entries", "format=duration",
+             "-of", "csv=p=0", video_path],
+            capture_output=True, text=True
+        )
+        return float(r.stdout.strip())
+    except Exception:
+        try:
+            size = os.path.getsize(video_path)
+            return max(10, size / (1024 * 1024) * 3)
+        except Exception:
+            return None
+
+
+def get_video_fps(video_path):
+    """Get video FPS using ffprobe."""
+    try:
+        r = subprocess.run(
+            ["ffprobe", "-v", "quiet", "-select_streams", "v:0",
+             "-show_entries", "stream=r_frame_rate",
+             "-of", "csv=p=0", video_path],
+            capture_output=True, text=True
+        )
+        fps_str = r.stdout.strip()
+        if "/" in fps_str:
+            num, den = fps_str.split("/")
+            return float(num) / float(den)
+        return float(fps_str)
+    except Exception:
+        return FPS
+
+
+async def edit_segment(bridge, prompt, aspect, project_id, media_id,
+                       start_frame, end_frame, segment_num, output_dir):
+    """Edit a single segment and download."""
+    body = {
+        "mediaGenerationContext": build_generation_context("BLOCK_SILENCED_VIDEOS"),
+        "clientContext": build_client_context(project_id),
+        "requests": [{
+            "aspectRatio": aspect,
+            "textInput": {"structuredPrompt": {"parts": [{"text": prompt}]}},
+            "videoModelKey": "abra_edit",
+            "seed": random.randint(1, 9999),
+            "metadata": {},
+            "videoInput": {
+                "mediaId": media_id,
+                "startFrameIndex": start_frame,
+                "endFrameIndex": end_frame,
+            },
+        }],
+    }
+
+    start_sec = start_frame / FPS
+    end_sec = end_frame / FPS
+    log.info("✂️ Segment %d: %.0fs-%.0fs (frames %d-%d)",
+             segment_num, start_sec, end_sec, start_frame, end_frame)
+
+    result = await bridge.api_request(ENDPOINTS["generate_edit"], body)
+
+    status = result.get("status", 0)
+    if status != 200:
+        err = result.get("data", {})
+        if isinstance(err, dict):
+            err = err.get("error", {}).get("message", result.get("error", "Unknown"))
+        log.error("❌ Segment %d failed (%s): %s", segment_num, status, err)
+        return None
+
+    data = result.get("data", {})
+    media_list = data.get("media", [])
+    if not media_list:
+        log.error("❌ No media for segment %d", segment_num)
+        return None
+
+    result_media_id = media_list[0].get("name")
+    credits = data.get("remainingCredits", "?")
+    log.info("✅ Segment %d submitted! media_id=%s, credits=%s",
+             segment_num, result_media_id[:12], credits)
+
+    if not await poll_status(bridge, result_media_id, project_id):
+        return None
+
+    out_path = os.path.join(output_dir, f"segment_{segment_num:03d}.mp4")
+    temp_dir = os.path.join(output_dir, ".temp")
+    os.makedirs(temp_dir, exist_ok=True)
+    temp_path = os.path.join(temp_dir, f"segment_{segment_num:03d}.mp4")
+
+    if await download_video(bridge, result_media_id, temp_path):
+        # Auto-remove watermark
+        try:
+            from omniflash.watermark import remove_watermark_video
+            remove_watermark_video(temp_path, out_path, show_progress=False)
+            os.remove(temp_path)
+        except Exception as e:
+            os.replace(temp_path, out_path)
+            log.warning("⚠️  Watermark removal failed for segment %d: %s", segment_num, e)
+        # Cleanup empty .temp dir
+        try:
+            os.rmdir(temp_dir)
+        except OSError:
+            pass
+        return out_path
+    return None
+
+
+async def run(args):
+    aspect = ASPECTS.get(args.aspect, "VIDEO_ASPECT_RATIO_PORTRAIT")
+
+    total_seconds = args.total_seconds
+    fps = FPS
+
+    if args.video_file and os.path.exists(args.video_file):
+        if not total_seconds:
+            total_seconds = get_video_duration(args.video_file)
+            log.info("📹 Video: %s (%.1fs)", args.video_file, total_seconds or 0)
+        fps = get_video_fps(args.video_file)
+        log.info("📹 FPS: %.1f", fps)
+
+    if not total_seconds:
+        log.error("❌ Can't determine video duration. Use --total-seconds")
+        return
+
+    os.makedirs(args.output, exist_ok=True)
+
+    # Calculate segments
+    segments = []
+    current = 0
+    seg_num = 1
+    while current < total_seconds:
+        start_frame = int(current * fps)
+        end_frame = int(min(current + SEGMENT_DURATION, total_seconds) * fps)
+        if end_frame <= start_frame:
+            break
+        segments.append((seg_num, start_frame, end_frame))
+        current += SEGMENT_DURATION
+        seg_num += 1
+
+    log.info("📋 Total: %.1fs → %d segments of %ds each",
+             total_seconds, len(segments), SEGMENT_DURATION)
+    log.info("─" * 50)
+
+    bridge = ExtensionBridge()
+    await bridge.start()
+    if not await bridge.wait_for_extension(timeout=30):
+        return
+
+    # Process segments (max 5 concurrent)
+    semaphore = asyncio.Semaphore(5)
+    results = [None] * len(segments)
+
+    async def process_segment(idx, seg_num, start_frame, end_frame):
+        async with semaphore:
+            out = await edit_segment(
+                bridge, args.prompt, aspect, args.project_id,
+                args.media_id, start_frame, end_frame, seg_num, args.output
+            )
+            results[idx] = out
+
+    tasks = [
+        asyncio.create_task(process_segment(idx, sn, sf, ef))
+        for idx, (sn, sf, ef) in enumerate(segments)
+    ]
+    await asyncio.gather(*tasks)
+    await bridge.close()
+
+    saved = [r for r in results if r]
+
+    log.info("─" * 50)
+    log.info("🎉 Done! %d/%d segments saved to %s/", len(saved), len(segments), args.output)
+    for f in saved:
+        log.info("   ✅ %s", os.path.basename(f))
+
+    # Merge with ffmpeg
+    if len(saved) > 1 and args.merge:
+        merge_path = os.path.join(args.output, "merged_output.mp4")
+        log.info("🔗 Merging %d segments...", len(saved))
+        try:
+            concat_file = os.path.join(args.output, "concat.txt")
+            with open(concat_file, "w") as f:
+                for s in saved:
+                    f.write(f"file '{os.path.abspath(s)}'\n")
+            subprocess.run([
+                "ffmpeg", "-y", "-f", "concat", "-safe", "0",
+                "-i", concat_file, "-c", "copy", merge_path
+            ], capture_output=True)
+            os.remove(concat_file)
+            # Auto-remove watermark from merged output
+            try:
+                from omniflash.watermark import remove_watermark_video
+                clean_path = remove_watermark_video(merge_path, show_progress=False)
+                os.replace(clean_path, merge_path)
+            except Exception:
+                pass
+            log.info("✅ Merged: %s", merge_path)
+        except Exception as e:
+            log.warning("⚠️ Merge failed (ffmpeg needed): %s", e)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Omni Flash — Full Video Editor")
+    parser.add_argument("prompt", help="Edit prompt")
+    parser.add_argument("--media-id", "-m", required=True, help="Flow media ID")
+    parser.add_argument("--video-file", "-v", help="Local video (for duration/fps)")
+    parser.add_argument("--total-seconds", "-t", type=float)
+    parser.add_argument("--output", "-o", default="output", help="Output directory")
+    parser.add_argument("--aspect", "-a", choices=["portrait", "landscape"], default="portrait")
+    parser.add_argument("--merge", action="store_true")
+    parser.add_argument("--project-id", "-p", default=DEFAULT_PROJECT)
+    args = parser.parse_args()
+    asyncio.run(run(args))
+
+
+if __name__ == "__main__":
+    main()

flow-agent/cli/generate.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""CLI — Generate video from text prompt (T2V) or edit existing video (V2V).
+
+Usage:
+    python -m cli.generate "A dragon breathing fire"
+    python -m cli.generate "A dragon breathing fire" --aspect landscape -o dragon.mp4
+    python -m cli.generate "Make it anime" --edit MEDIA_ID
+"""
+
+import argparse
+import asyncio
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from omniflash import (
+    ExtensionBridge, generate_video, edit_video,
+    poll_status, download_video, ASPECTS, DEFAULT_PROJECT,
+)
+from omniflash.generators.i2v import upload_image, generate_video_i2v, generate_video_fl, generate_video_r2v
+
+
+async def run(args):
+    aspect = ASPECTS.get(args.aspect, "VIDEO_ASPECT_RATIO_PORTRAIT")
+
+    bridge = ExtensionBridge()
+    await bridge.start()
+
+    if not await bridge.wait_for_extension(timeout=30):
+        return
+
+    # Auto-upload local image files
+    async def resolve_image(path_or_id):
+        if os.path.exists(path_or_id):
+            mid = await upload_image(bridge, path_or_id)
+            if mid:
+                print(f"📤 Uploaded: {path_or_id} → {mid[:12]}...")
+            return mid
+        return path_or_id
+
+    if args.start and args.end:
+        # First+Last frame mode
+        start_id = await resolve_image(args.start)
+        end_id = await resolve_image(args.end)
+        if not start_id or not end_id:
+            await bridge.close()
+            return
+        media_ids = await generate_video_fl(bridge, args.prompt, aspect, args.project_id,
+                                             start_image_id=start_id, end_image_id=end_id,
+                                             duration=args.duration)
+    elif args.start:
+        # I2V mode (start image only)
+        start_id = await resolve_image(args.start)
+        if not start_id:
+            await bridge.close()
+            return
+        media_ids = await generate_video_i2v(bridge, args.prompt, aspect, args.project_id,
+                                              image_media_id=start_id, duration=args.duration)
+    elif args.ref:
+        # Reference images mode
+        ref_ids = []
+        for r in args.ref:
+            mid = await resolve_image(r)
+            if mid:
+                ref_ids.append(mid)
+        if not ref_ids:
+            await bridge.close()
+            return
+        media_ids = await generate_video_r2v(bridge, args.prompt, aspect, args.project_id,
+                                              ref_media_ids=ref_ids, duration=args.duration)
+    elif args.edit:
+        media_ids = await edit_video(bridge, args.prompt, aspect, args.project_id,
+                                     video_media_id=args.edit, duration=args.duration)
+    else:
+        media_ids = await generate_video(bridge, args.prompt, aspect, args.project_id,
+                                         duration=args.duration, count=args.count)
+
+    if not media_ids:
+        await bridge.close()
+        return
+
+    for i, media_id in enumerate(media_ids):
+        label = f"[{i+1}/{len(media_ids)}] " if len(media_ids) > 1 else ""
+        print(f"{label}Polling {media_id[:12]}...")
+        if not await poll_status(bridge, media_id, args.project_id):
+            continue
+
+        if len(media_ids) == 1:
+            out_path = args.output
+        else:
+            base, ext = os.path.splitext(args.output)
+            out_path = f"{base}_{i+1}{ext}"
+
+        # Setup temp dir for download
+        out_dir = os.path.dirname(out_path) or "."
+        temp_dir = os.path.join(out_dir, ".temp")
+        os.makedirs(temp_dir, exist_ok=True)
+        temp_path = os.path.join(temp_dir, os.path.basename(out_path))
+
+        if await download_video(bridge, media_id, temp_path):
+            # Auto-remove watermark unless --no-clean
+            if not args.no_clean:
+                try:
+                    from omniflash.watermark import remove_watermark_video
+                    remove_watermark_video(temp_path, out_path)
+                    os.remove(temp_path)
+                    print(f"🧹 Watermark removed!")
+                except Exception as e:
+                    # Fallback: move temp to output as-is
+                    os.replace(temp_path, out_path)
+                    print(f"⚠️  Watermark removal failed: {e}")
+            else:
+                os.replace(temp_path, out_path)
+
+            # Cleanup empty .temp dir
+            try:
+                os.rmdir(temp_dir)
+            except OSError:
+                pass
+
+            print(f"🎉 Done! {out_path}")
+
+    await bridge.close()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Omni Flash — Video Generator")
+    parser.add_argument("prompt", help="Text prompt for video")
+    parser.add_argument("--output", "-o", default="omni_output.mp4", help="Output file")
+    parser.add_argument("--aspect", "-a", choices=["portrait", "landscape"], default="portrait")
+    parser.add_argument("--duration", "-d", type=int, choices=[4, 6, 8, 10], default=10)
+    parser.add_argument("--count", "-c", type=int, choices=[1, 2, 3, 4], default=1)
+    parser.add_argument("--edit", "-e", metavar="MEDIA_ID",
+                        help="Edit existing video (V2V mode)")
+    parser.add_argument("--start", "-s", metavar="IMAGE",
+                        help="Start frame image (file path or media_id)")
+    parser.add_argument("--end", metavar="IMAGE",
+                        help="End frame image (use with --start for FL mode)")
+    parser.add_argument("--ref", "-r", nargs="+", metavar="IMAGE",
+                        help="Reference images for R2V mode")
+    parser.add_argument("--project-id", "-p", default=DEFAULT_PROJECT)
+    parser.add_argument("--no-clean", action="store_true",
+                        help="Skip automatic watermark removal")
+    args = parser.parse_args()
+    asyncio.run(run(args))
+
+
+if __name__ == "__main__":
+    main()

flow-agent/cli/image.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""CLI — Generate image from text prompt (T2I).
+
+Usage:
+    python -m cli.image "A cat wearing sunglasses on a beach"
+    python -m cli.image "Dragon in cyberpunk city" --aspect landscape --count 4
+    python -m cli.image "Logo design" --aspect square -o logo.png
+"""
+
+import argparse
+import asyncio
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from omniflash import ExtensionBridge, DEFAULT_PROJECT
+from omniflash.generators.t2i import generate_image, download_image, IMAGE_ASPECTS
+
+
+async def run(args):
+    aspect = args.aspect
+
+    bridge = ExtensionBridge()
+    await bridge.start()
+
+    if not await bridge.wait_for_extension(timeout=30):
+        return
+
+    # Handle ref images: auto-upload local files
+    ref_ids = []
+    if args.ref:
+        from omniflash.generators.i2v import upload_image
+        for ref in args.ref:
+            if os.path.exists(ref):
+                print(f"📤 Uploading reference: {ref}")
+                mid = await upload_image(bridge, ref)
+                if mid:
+                    ref_ids.append(mid)
+                    print(f"   media_id={mid[:12]}...")
+            else:
+                # Assume it's already a media_id
+                ref_ids.append(ref)
+
+    results = await generate_image(
+        bridge, args.prompt, aspect, args.project_id,
+        count=args.count, ref_media_ids=ref_ids or None
+    )
+
+    if not results:
+        await bridge.close()
+        return
+
+    os.makedirs(os.path.dirname(args.output) or ".", exist_ok=True)
+
+    for i, r in enumerate(results):
+        if not r.get("image_url"):
+            print(f"⚠️  Image {i+1}: no URL")
+            continue
+
+        if len(results) == 1:
+            out_path = args.output
+        else:
+            base, ext = os.path.splitext(args.output)
+            out_path = f"{base}_{i+1}{ext}"
+
+        if await download_image(bridge, r["image_url"], out_path):
+            print(f"🎉 Done! {out_path}")
+
+    await bridge.close()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Flow Agent — Image Generator")
+    parser.add_argument("prompt", help="Text prompt for image")
+    parser.add_argument("--output", "-o", default="output/image.png", help="Output file")
+    parser.add_argument("--aspect", "-a",
+                        choices=list(IMAGE_ASPECTS.keys()),
+                        default="portrait",
+                        help="Aspect ratio")
+    parser.add_argument("--count", "-c", type=int, choices=[1, 2, 3, 4], default=1,
+                        help="Generate 1-4 variations")
+    parser.add_argument("--ref", "-r", nargs="+", metavar="IMAGE",
+                        help="Reference image(s): file path or media_id")
+    parser.add_argument("--project-id", "-p", default=DEFAULT_PROJECT)
+    args = parser.parse_args()
+    asyncio.run(run(args))
+
+
+if __name__ == "__main__":
+    main()

flow-agent/cli/sniff.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""CLI — API request sniffer.
+
+Captures all Flow UI API requests for endpoint discovery.
+
+Usage:
+    python -m cli.sniff
+    python -m cli.sniff --save sniffed.json
+"""
+
+import asyncio
+import argparse
+import json
+import logging
+import os
+import sys
+from http.server import HTTPServer, BaseHTTPRequestHandler
+import threading
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+for _pkg in ["websockets"]:
+    try:
+        __import__(_pkg)
+    except ImportError:
+        os.system(f"{sys.executable} -m pip install {_pkg} -q")
+
+import websockets
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s", datefmt="%H:%M:%S")
+log = logging.getLogger("cli.sniff")
+
+all_requests = []
+
+IGNORE = {"batchLog", "frontendEvents", "fetchUserRecommendations", "flowAgent/applets",
+          "savedSharedApplets", "models/statuses"}
+
+
+def make_handler(save_file):
+    class Handler(BaseHTTPRequestHandler):
+        def do_POST(self):
+            length = int(self.headers.get("Content-Length", 0))
+            body = json.loads(self.rfile.read(length)) if length else {}
+
+            if body.get("type") == "sniffed_video_request":
+                url = body.get("url", "")
+                if not any(n in url for n in IGNORE):
+                    method = body.get("method", "?")
+                    payload = body.get("payload", "")
+
+                    log.info("─" * 60)
+                    log.info("🔍 %s %s", method, url.split("?")[0])
+                    if payload and payload != "(empty)":
+                        try:
+                            parsed = json.loads(payload)
+                            log.info("   %s", json.dumps(parsed, indent=2)[:2000])
+                        except (json.JSONDecodeError, TypeError):
+                            log.info("   %s", str(payload)[:1000])
+
+                    entry = {
+                        "url": url,
+                        "method": method,
+                        "payload": payload,
+                        "timestamp": body.get("timestamp"),
+                    }
+                    all_requests.append(entry)
+
+                    if save_file:
+                        with open(save_file, "w") as f:
+                            json.dump(all_requests, f, indent=2)
+
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.end_headers()
+            self.wfile.write(b'{"ok":true}')
+
+        def do_OPTIONS(self):
+            self.send_response(200)
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Access-Control-Allow-Methods", "POST")
+            self.send_header("Access-Control-Allow-Headers", "Content-Type")
+            self.end_headers()
+
+        def log_message(self, *a):
+            pass
+
+    return Handler
+
+
+async def on_connect(ws):
+    log.info("✅ Extension connected!")
+    async for raw in ws:
+        data = json.loads(raw)
+        if data.get("type") == "token_captured":
+            log.info("🔑 Token captured")
+
+
+async def run(args):
+    Handler = make_handler(args.save)
+    srv = HTTPServer(("127.0.0.1", args.port), Handler)
+    threading.Thread(target=srv.serve_forever, daemon=True).start()
+
+    log.info("⚡ WS server on ws://127.0.0.1:%d", args.ws_port)
+    log.info("⚡ HTTP callback on http://127.0.0.1:%d", args.port)
+    if args.save:
+        log.info("💾 Saving to: %s", args.save)
+    log.info("👉 Open Flow UI and perform any action...")
+    log.info("─" * 60)
+
+    async with websockets.serve(on_connect, "127.0.0.1", args.ws_port):
+        await asyncio.Future()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Flow API Sniffer")
+    parser.add_argument("--save", "-s", help="Save to JSON file")
+    parser.add_argument("--port", type=int, default=8100)
+    parser.add_argument("--ws-port", type=int, default=9222)
+    args = parser.parse_args()
+    asyncio.run(run(args))
+
+
+if __name__ == "__main__":
+    main()

flow-agent/cli/upload.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""CLI — Upload video or batch upload directory.
+
+Usage:
+    python -m cli.upload video.mp4
+    python -m cli.upload chunks/ --batch
+"""
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from omniflash.upload import upload_video
+
+
+async def run(args):
+    if args.batch or os.path.isdir(args.path):
+        # Batch upload all mp4 in directory
+        directory = args.path
+        chunks = sorted([f for f in os.listdir(directory) if f.endswith(".mp4")])
+        if not chunks:
+            print(f"❌ No .mp4 files found in {directory}")
+            return
+        print(f"📁 Found {len(chunks)} videos in {directory}")
+        for i, chunk in enumerate(chunks, 1):
+            path = os.path.join(directory, chunk)
+            print(f"\n{'─' * 50}")
+            print(f"[{i}/{len(chunks)}] {chunk}")
+            try:
+                await upload_video(path, args.project_id)
+            except Exception as e:
+                print(f"❌ {chunk} failed: {e}")
+    else:
+        # Single file upload
+        result = await upload_video(args.path, args.project_id)
+        print(json.dumps(result, indent=2))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Omni Flash — Upload Video")
+    parser.add_argument("path", help="Video file or directory of videos")
+    parser.add_argument("--batch", "-b", action="store_true",
+                        help="Batch upload all .mp4 in directory")
+    parser.add_argument("--project-id", "-p",
+                        default="ff92d5cc-8a03-41d2-b59e-e0774d17bcf6")
+    args = parser.parse_args()
+    asyncio.run(run(args))
+
+
+if __name__ == "__main__":
+    main()

flow-agent/error.md

@@ -0,0 +1,74 @@
+# 🛠️ Flow Agent API Troubleshooting Guide (error.md)
+
+This document contains standard error scenarios and how to resolve them quickly.
+
+---
+
+## 1. Error: `OSError: [Errno 48] Address already in use`
+* **Symptom**: The server fails to start and exits with: `OSError: [Errno 48] Address already in use` (typically for port `8000`, `8100`, or `9222`).
+* **Cause**: Another instance of the API server or a background flow-agent process is already running and occupying the port.
+* **Resolution**:
+  Run the following commands in your terminal to find and kill the process:
+  ```bash
+  # Clear API server port (8000)
+  kill -9 $(lsof -t -i:8000) 2>/dev/null || true
+
+  # Clear Extension bridge HTTP callback port (8100)
+  kill -9 $(lsof -t -i:8100) 2>/dev/null || true
+
+  # Clear Extension bridge WebSocket port (9222)
+  kill -9 $(lsof -t -i:9222) 2>/dev/null || true
+  ```
+
+---
+
+## 2. Error: `Internal Server Error (500) - RuntimeError: curl failed`
+* **Symptom**: Step `Uploading Video to Flow` fails with Status Code `500` and the server console prints: `RuntimeError: curl failed: ...`
+* **Cause**: Your terminal session has sandbox/proxy environment variables active (`http_proxy`, `https_proxy`, `HTTP_PROXY`, or `HTTPS_PROXY` might be set by the AI agent sandbox). This causes `curl` to route all Google Cloud Storage uploads through a proxy that blocks the connection.
+* **Resolution**:
+  Clear the proxy variables in your terminal window before starting the server and running the test script:
+  ```bash
+  # 1. Unset the proxy variables
+  unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY
+
+  # 2. Restart the API server in this terminal
+  venv/bin/python -m cli.api --port 8000
+  ```
+  *(Make sure to also run `unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY` in your testing/client terminal window as well).*
+
+---
+
+## 3. Error: `Google Flow extension is not connected or unauthorized`
+* **Symptom**: `/health` returns `has_flow_key: false` and generation calls return: `"Google Flow extension is not connected or unauthorized. Make sure Google Flow tab is open in Chrome."`
+* **Cause**: The Extension Bridge WS is connected, but the Chrome extension is unable to capture the auth token (`flowKey`) because Google Flow is either not open, has gone idle, or your Google account has logged out.
+* **Resolution**:
+  1. Open Chrome.
+  2. Make sure you are logged into your Google account at **[labs.google/fx/tools/flow](https://labs.google/fx/tools/flow)**.
+  3. Reload the page. The extension icon in your extension bar should show a green indicator.
+  4. Once logged in, the extension will automatically push the token to the server and heal the state.
+
+---
+
+## 4. Error: `Failed (0): TIMEOUT`
+* **Symptom**: Request fails after 90 seconds with `TIMEOUT`.
+* **Cause**: Google Flow took too long to respond, or there is an active **reCAPTCHA challenge** popped up on your Chrome browser that requires manual verification.
+* **Resolution**:
+  1. Open Chrome and inspect the Google Flow tab.
+  2. If a reCAPTCHA prompt is present, solve it.
+  3. Reload the tab to refresh the connection, wait 5 seconds, and try your request again.
+
+---
+
+## 5. Error: `zsh: no such file or directory: venv/bin/python`
+* **Symptom**: Running server or test script returns: `zsh: no such file or directory: venv/bin/python` or similar file errors.
+* **Cause**: The command is run from the parent workspace folder (`N8N-Agent`) instead of the cloned `flow-agent` project folder where the virtual environment (`venv`) resides.
+* **Resolution**:
+  Always change your directory to the `flow-agent` folder before running commands, or use the absolute paths:
+  ```bash
+  # Go to the correct directory first
+  cd /path/to/flow-agent
+  
+  # Then run the command
+  venv/bin/python -m cli.api --port 8000
+  ```
+

flow-agent/extension/background.js

@@ -0,0 +1,879 @@
+/**
+ * Flow Agent — Chrome Extension Background Service Worker
+ *
+ * Connects to local Python agent via WebSocket (agent runs WS server).
+ * Captures bearer token, solves reCAPTCHA, proxies API calls through browser.
+ */
+
+const AGENT_WS_URL = 'ws://127.0.0.1:9222';
+// NOTE: This is a browser-restricted public API key — safe to ship in extension bundles.
+const API_KEY = 'AIzaSyBtrm0o5ab1c-Ec8ZuLcGt3oJAA5VWt3pY';
+
+let ws = null;
+let flowKey = null;
+let callbackSecret = null;  // Auth secret for HTTP callback, received from server on WS connect
+let state = 'off'; // off | idle | running
+let manualDisconnect = false;
+let metrics = {
+  tokenCapturedAt: null,
+  requestCount: 0,   // captcha-consuming requests only (gen image/video/upscale)
+  successCount: 0,
+  failedCount: 0,
+  lastError: null,
+};
+
+// ─── URL → Log Type Classifier ─────────────────────────────
+
+// Visible log types — only these appear in the request log
+const _VISIBLE_TYPES = new Set(['GEN_IMG', 'GEN_VID', 'GEN_VID_REF', 'UPSCALE', 'TRACKING', 'URL_REFRESH']);
+
+function _classifyApiUrl(url) {
+  if (url.includes('uploadImage'))                     return 'UPLOAD';
+  if (url.includes('batchGenerateImages'))              return 'GEN_IMG';
+  if (url.includes('UpsampleVideo'))                   return 'UPSCALE';
+  if (url.includes('ReferenceImages'))                 return 'GEN_VID_REF';
+  if (url.includes('batchAsyncGenerateVideo'))          return 'GEN_VID';
+  if (url.includes('batchCheckAsync'))                  return 'POLL';
+  if (url.includes('upsampleImage'))                   return 'UPS_IMG';
+  if (url.includes('/media/'))                         return 'MEDIA';
+  if (url.includes('/credits'))                        return 'CREDITS';
+  return 'API';
+}
+
+// ─── Request Log ────────────────────────────────────────────
+
+let requestLog = [];
+
+function addRequestLog(entry) {
+  requestLog.unshift(entry);
+  if (requestLog.length > 100) requestLog.pop();
+  broadcastRequestLog();
+}
+
+function updateRequestLog(id, updates) {
+  const entry = requestLog.find((e) => e.id === id);
+  if (entry) Object.assign(entry, updates);
+  broadcastRequestLog();
+}
+
+function broadcastRequestLog() {
+  chrome.runtime.sendMessage({ type: 'REQUEST_LOG_UPDATE', log: requestLog }).catch(() => {});
+}
+
+// ─── Startup ────────────────────────────────────────────────
+
+chrome.runtime.onInstalled.addListener(init);
+chrome.runtime.onStartup.addListener(init);
+chrome.alarms.onAlarm.addListener(async (alarm) => {
+  if (alarm.name === 'reconnect') connectToAgent();
+  if (alarm.name === 'keepAlive') keepAlive();
+  if (alarm.name === 'token-refresh') {
+    await captureTokenFromFlowTab();
+  }
+});
+
+async function init() {
+  const data = await chrome.storage.local.get(['flowKey', 'metrics', 'callbackSecret']);
+  if (data.flowKey) flowKey = data.flowKey;
+  if (data.metrics) Object.assign(metrics, data.metrics);
+  if (data.callbackSecret) callbackSecret = data.callbackSecret;
+  connectToAgent();
+  chrome.alarms.create('keepAlive', { periodInMinutes: 0.4 });
+}
+
+// ─── Token Capture ──────────────────────────────────────────
+
+chrome.webRequest.onBeforeSendHeaders.addListener(
+  (details) => {
+    if (!details?.requestHeaders?.length) return;
+    const authHeader = details.requestHeaders.find(
+      (h) => h.name?.toLowerCase() === 'authorization',
+    );
+    const value = authHeader?.value || '';
+    if (!value.startsWith('Bearer ya29.')) return;
+
+    const token = value.replace(/^Bearer\s+/i, '').trim();
+    if (!token) return;
+
+    // Always update — even if same token string, refresh the timestamp
+    flowKey = token;
+    metrics.tokenCapturedAt = Date.now();
+    chrome.storage.local.set({ flowKey, metrics });
+    console.log('[Flow Agent] Bearer token captured');
+
+    // Notify agent
+    if (ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: 'token_captured', flowKey }));
+    }
+  },
+  { urls: ['https://aisandbox-pa.googleapis.com/*', 'https://labs.google/*'] },
+  ['requestHeaders', 'extraHeaders'],
+);
+
+let _openingFlowTab = false;
+
+async function captureTokenFromFlowTab() {
+  const tabs = await chrome.tabs.query({
+    url: ['https://labs.google/fx/tools/flow*', 'https://labs.google/fx/*/tools/flow*'],
+  });
+  if (!tabs.length) {
+    if (_openingFlowTab) {
+      console.log('[Flow Agent] Flow tab already opening, skipping');
+      return;
+    }
+    _openingFlowTab = true;
+    try {
+      console.log('[Flow Agent] No Flow tab found — opening one in background');
+      await chrome.tabs.create({ url: 'https://labs.google/fx/tools/flow', active: false });
+      await sleep(3000);
+      const retryTabs = await chrome.tabs.query({
+        url: ['https://labs.google/fx/tools/flow*', 'https://labs.google/fx/*/tools/flow*'],
+      });
+      if (!retryTabs.length) {
+        console.log('[Flow Agent] Flow tab not ready yet after open');
+        return;
+      }
+      await chrome.scripting.executeScript({
+        target: { tabId: retryTabs[0].id },
+        files: ['content.js'],
+      });
+      console.log('[Flow Agent] Token refresh triggered on newly opened Flow tab');
+    } catch (e) {
+      console.error('[Flow Agent] Token refresh failed after opening tab:', e);
+    } finally {
+      _openingFlowTab = false;
+    }
+    return;
+  }
+  try {
+    await chrome.scripting.executeScript({
+      target: { tabId: tabs[0].id },
+      files: ['content.js'],
+    });
+    console.log('[Flow Agent] Token refresh triggered on Flow tab');
+  } catch (e) {
+    console.error('[Flow Agent] Token refresh failed:', e);
+  }
+}
+
+// ─── WebSocket to Agent ─────────────────────────────────────
+
+function connectToAgent() {
+  if (manualDisconnect) return;
+  if (ws?.readyState === WebSocket.CONNECTING) return;
+  if (ws?.readyState === WebSocket.OPEN) return;
+
+  try {
+    ws = new WebSocket(AGENT_WS_URL);
+  } catch (e) {
+    console.error('[Flow Agent] WS connect error:', e);
+    scheduleReconnect();
+    return;
+  }
+
+  ws.onopen = () => {
+    console.log('[Flow Agent] Connected to agent');
+    chrome.alarms.clear('reconnect');
+    setState('idle');
+
+    // Token refresh alarm — 45 min gives buffer before ~60 min expiry
+    chrome.alarms.create('token-refresh', { periodInMinutes: 45 });
+
+    // Send current state + resend token if we have one
+    ws.send(JSON.stringify({
+      type: 'extension_ready',
+      flowKeyPresent: !!flowKey,
+      tokenAge: flowKey && metrics.tokenCapturedAt ? Date.now() - metrics.tokenCapturedAt : null,
+    }));
+    if (flowKey) {
+      ws.send(JSON.stringify({ type: 'token_captured', flowKey }));
+    }
+  };
+
+  ws.onmessage = async ({ data }) => {
+    try {
+      const msg = JSON.parse(data);
+
+      if (msg.method === 'api_request') {
+        await handleApiRequest(msg);
+      } else if (msg.method === 'trpc_request') {
+        await handleTrpcRequest(msg);
+      } else if (msg.method === 'upload_video') {
+        await handleUploadVideo(msg);
+      } else if (msg.method === 'solve_captcha') {
+        await handleSolveCaptcha(msg);
+      } else if (msg.method === 'get_status') {
+        sendToAgent({
+          id: msg.id,
+          result: {
+            state,
+            flowKeyPresent: !!flowKey,
+            manualDisconnect,
+            tokenAge: metrics.tokenCapturedAt ? Date.now() - metrics.tokenCapturedAt : null,
+            metrics,
+          },
+        });
+      } else if (msg.method === 'open_flow_tab') {
+        // Python bridge asks us to open/focus a Flow tab
+        console.log('[Flow Agent] Agent requested: open Flow tab');
+        const tabs = await chrome.tabs.query({
+          url: ['https://labs.google/fx/tools/flow*', 'https://labs.google/fx/*/tools/flow*'],
+        });
+        if (tabs.length) {
+          // Tab exists — refresh it to trigger fresh API calls → token capture
+          await chrome.tabs.reload(tabs[0].id);
+          console.log('[Flow Agent] Refreshed existing Flow tab');
+        } else {
+          // No tab — open one (active so it loads properly)
+          await chrome.tabs.create({ url: 'https://labs.google/fx/tools/flow', active: true });
+          console.log('[Flow Agent] Opened new Flow tab');
+        }
+        // Wait for page to load and make API calls that trigger token capture
+        await sleep(5000);
+        // If token was captured by webRequest during page load, send it
+        if (flowKey && ws?.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'token_captured', flowKey }));
+          console.log('[Flow Agent] Sent stored token after tab open');
+        } else {
+          // Try reading from storage as fallback
+          const data = await chrome.storage.local.get(['flowKey']);
+          if (data.flowKey) {
+            flowKey = data.flowKey;
+            if (ws?.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'token_captured', flowKey }));
+              console.log('[Flow Agent] Sent token from storage after tab open');
+            }
+          }
+        }
+      } else if (msg.method === 'refresh_flow_tab') {
+        // Python bridge asks us to refresh token
+        console.log('[Flow Agent] Agent requested: refresh token');
+        await captureTokenFromFlowTab();
+        await sleep(3000);
+        // Actively send token if we have one
+        if (flowKey && ws?.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'token_captured', flowKey }));
+          console.log('[Flow Agent] Sent token after refresh');
+        } else {
+          const data = await chrome.storage.local.get(['flowKey']);
+          if (data.flowKey) {
+            flowKey = data.flowKey;
+            if (ws?.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'token_captured', flowKey }));
+              console.log('[Flow Agent] Sent token from storage after refresh');
+            }
+          }
+        }
+      } else if (msg.type === 'callback_secret') {
+        callbackSecret = msg.secret;
+        chrome.storage.local.set({ callbackSecret: msg.secret });
+        console.log('[Flow Agent] Received callback secret');
+      } else if (msg.type === 'pong') {
+        // keepalive response
+      }
+    } catch (e) {
+      console.error('[Flow Agent] Message error:', e);
+    }
+  };
+
+  ws.onclose = () => {
+    setState('off');
+    chrome.alarms.clear('token-refresh');
+    if (!manualDisconnect) scheduleReconnect();
+  };
+
+  ws.onerror = (e) => {
+    console.error('[Flow Agent] WS error:', e);
+    metrics.lastError = 'WS_ERROR';
+    chrome.storage.local.set({ metrics });
+  };
+}
+
+function scheduleReconnect() {
+  chrome.alarms.create('reconnect', { delayInMinutes: 0.083 }); // ~5s
+}
+
+function keepAlive() {
+  if (ws?.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: 'ping' }));
+  } else {
+    connectToAgent();
+  }
+}
+
+function sendToAgent(msg) {
+  // API responses (with msg.id) go via HTTP — immune to WS disconnect
+  if (msg.id) {
+    fetch('http://127.0.0.1:8100/api/ext/callback', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(msg),
+    }).catch(() => {
+      // HTTP failed — fallback to WS
+      if (ws?.readyState === WebSocket.OPEN) ws.send(JSON.stringify(msg));
+    });
+    return;
+  }
+  // Non-response messages (ping, status) or no secret yet — use WS
+  if (ws?.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(msg));
+  }
+}
+
+// ─── reCAPTCHA Solving ──────────────────────────────────────
+
+async function requestCaptchaFromTab(tabId, requestId, pageAction) {
+  try {
+    return await chrome.tabs.sendMessage(tabId, {
+      type: 'GET_CAPTCHA',
+      requestId,
+      pageAction,
+    });
+  } catch (error) {
+    const msg = error?.message || '';
+    const shouldInject =
+      msg.includes('Receiving end does not exist') ||
+      msg.includes('Could not establish connection');
+    if (!shouldInject) throw error;
+
+    // Inject content script and retry
+    await chrome.scripting.executeScript({
+      target: { tabId },
+      files: ['content.js'],
+    });
+    await sleep(200);
+    return await chrome.tabs.sendMessage(tabId, {
+      type: 'GET_CAPTCHA',
+      requestId,
+      pageAction,
+    });
+  }
+}
+
+async function solveCaptcha(requestId, captchaAction) {
+  const tabs = await chrome.tabs.query({
+    url: ['https://labs.google/fx/tools/flow*', 'https://labs.google/fx/*/tools/flow*'],
+  });
+
+  if (!tabs.length) {
+    // Auto-open Flow tab and wait briefly before returning error
+    try {
+      await chrome.tabs.create({ url: 'https://labs.google/fx/tools/flow', active: false });
+      await sleep(3000);
+      // Retry tab query after opening
+      const retryTabs = await chrome.tabs.query({
+        url: ['https://labs.google/fx/tools/flow*', 'https://labs.google/fx/*/tools/flow*'],
+      });
+      if (!retryTabs.length) return { error: 'NO_FLOW_TAB' };
+      const resp = await Promise.race([
+        requestCaptchaFromTab(retryTabs[0].id, requestId, captchaAction),
+        new Promise((_, rej) => setTimeout(() => rej(new Error('CAPTCHA_TIMEOUT')), 30000)),
+      ]);
+      return resp;
+    } catch (e) {
+      return { error: e.message || 'NO_FLOW_TAB' };
+    }
+  }
+
+  try {
+    const resp = await Promise.race([
+      requestCaptchaFromTab(tabs[0].id, requestId, captchaAction),
+      new Promise((_, rej) => setTimeout(() => rej(new Error('CAPTCHA_TIMEOUT')), 30000)),
+    ]);
+    return resp;
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+async function handleSolveCaptcha(msg) {
+  const { id, params } = msg;
+  const result = await solveCaptcha(id, params?.captchaAction || 'VIDEO_GENERATION');
+
+  // Standalone captcha solve counts as captcha-consuming
+  metrics.requestCount++;
+  if (result?.token) {
+    metrics.successCount++;
+  } else {
+    metrics.failedCount++;
+    metrics.lastError = result?.error || 'NO_TOKEN';
+  }
+  chrome.storage.local.set({ metrics });
+
+  sendToAgent({ id, result });
+}
+
+// ─── API Request Proxy ──────────────────────────────────────
+
+async function handleTrpcRequest(msg) {
+  const { id, params } = msg;
+  const { url, method = 'POST', headers = {}, body } = params;
+
+  if (!url || !url.startsWith('https://labs.google/')) {
+    sendToAgent({ id, error: 'INVALID_TRPC_URL' });
+    return;
+  }
+
+  setState('running');
+  // TRPC calls don't consume captcha — don't count in metrics
+
+  const logId = id;
+  const logType = url.includes('createProject') ? 'CREATE_PROJECT' : 'TRPC';
+  // TRPC calls are silent — don't show in request log
+
+  const fetchHeaders = { 'Content-Type': 'application/json', ...headers };
+  if (flowKey) {
+    fetchHeaders['authorization'] = `Bearer ${flowKey}`;
+  }
+
+  try {
+    const resp = await fetch(url, {
+      method,
+      headers: fetchHeaders,
+      body: body ? JSON.stringify(body) : undefined,
+      credentials: 'include',
+    });
+    const data = await resp.json();
+    chrome.storage.local.set({ metrics });
+    updateRequestLog(logId, { status: 'success' });
+    sendToAgent({ id, status: resp.status, data });
+  } catch (e) {
+    console.error('[Flow Agent] tRPC request failed:', e);
+    chrome.storage.local.set({ metrics });
+    updateRequestLog(logId, { status: 'failed', error: e.message || 'TRPC_FETCH_FAILED' });
+    sendToAgent({ id, error: e.message || 'TRPC_FETCH_FAILED' });
+  } finally {
+    setState('idle');
+  }
+}
+
+
+async function handleUploadVideo(msg) {
+  const { id, params } = msg;
+  const { videoBase64, projectId, videoSize } = params;
+
+  try {
+    const tabs = await chrome.tabs.query({ url: '*://labs.google/*' });
+    if (!tabs.length) {
+      sendToAgent({ id, error: 'NO_FLOW_TAB' });
+      return;
+    }
+
+    const size = videoSize || (videoBase64 ? Math.floor(videoBase64.length * 3 / 4) : 0);
+
+    // Get session URL via page context XHR (needs session cookies)
+    const startResults = await chrome.scripting.executeScript({
+      target: { tabId: tabs[0].id },
+      world: 'MAIN',
+      func: (projId, sz) => {
+        return new Promise((resolve) => {
+          const xhr = new XMLHttpRequest();
+          xhr.open('POST', '/fx/api/upload-video?action=start');
+          xhr.setRequestHeader('X-Upload-Project-Id', projId);
+          xhr.setRequestHeader('X-Upload-Content-Type', 'video/mp4');
+          xhr.setRequestHeader('X-Upload-Content-Length', sz.toString());
+          xhr.withCredentials = true;
+          xhr.onload = () => {
+            let data;
+            try { data = JSON.parse(xhr.responseText); } catch { data = {}; }
+            resolve({
+              sessionUrl: data.sessionUrl || xhr.getResponseHeader('X-Upload-Session-Url') || '',
+              status: xhr.status,
+            });
+          };
+          xhr.onerror = () => resolve({ error: 'POST_FAILED' });
+          xhr.send();
+        });
+      },
+      args: [projectId, size],
+    });
+
+    const step1 = startResults?.[0]?.result;
+    if (!step1 || step1.error || !step1.sessionUrl) {
+      sendToAgent({ id, error: step1?.error || 'NO_SESSION_URL' });
+      return;
+    }
+
+    // Return sessionUrl + token — caller handles PUT
+    sendToAgent({
+      id,
+      result: {
+        sessionUrl: step1.sessionUrl,
+        token: flowKey || '',
+      },
+    });
+  } catch (e) {
+    sendToAgent({ id, error: `UPLOAD_ERROR: ${e.message}` });
+  }
+}
+
+async function handleApiRequest(msg) {
+  const { id, params } = msg;
+  const { url, method, headers, body, captchaAction } = params;
+
+  if (!url) {
+    sendToAgent({ id, error: 'MISSING_URL' });
+    return;
+  }
+
+  if (!url.startsWith('https://aisandbox-pa.googleapis.com/')) {
+    sendToAgent({ id, error: 'INVALID_URL' });
+    return;
+  }
+
+  setState('running');
+  const hasCaptcha = !!captchaAction;
+  if (hasCaptcha) metrics.requestCount++;
+
+  const logId = id;
+  const logType = _classifyApiUrl(url);
+  if (_VISIBLE_TYPES.has(logType)) {
+    const payloadSummary = body ? JSON.stringify(body).slice(0, 200) : null;
+    addRequestLog({ id: logId, type: logType, time: new Date().toISOString(), status: 'processing', error: null, outputUrl: null, url, payloadSummary });
+  }
+
+  try {
+    // Step 1: Solve captcha if needed
+    let captchaToken = null;
+    if (captchaAction) {
+      const captchaResult = await solveCaptcha(id, captchaAction);
+      captchaToken = captchaResult?.token || null;
+      if (!captchaToken) {
+        // Cannot proceed without captcha — API will 403
+        const err = captchaResult?.error || 'CAPTCHA_FAILED';
+        console.error(`[Flow Agent] Captcha failed for ${captchaAction}: ${err}`);
+        sendToAgent({ id, status: 403, error: `CAPTCHA_FAILED: ${err}` });
+        if (hasCaptcha) { metrics.failedCount++; metrics.lastError = `CAPTCHA_FAILED: ${err}`; }
+        chrome.storage.local.set({ metrics });
+        updateRequestLog(logId, { status: 'failed', error: `CAPTCHA_FAILED: ${err}` });
+        setState('idle');
+        return;
+      }
+    }
+
+    // Step 2: Inject captcha token into body
+    let finalBody = body;
+    if (captchaToken && finalBody) {
+      finalBody = JSON.parse(JSON.stringify(finalBody)); // deep clone
+      if (finalBody.clientContext?.recaptchaContext) {
+        finalBody.clientContext.recaptchaContext.token = captchaToken;
+      }
+      if (finalBody.requests && Array.isArray(finalBody.requests)) {
+        for (const req of finalBody.requests) {
+          if (req.clientContext?.recaptchaContext) {
+            req.clientContext.recaptchaContext.token = captchaToken;
+          }
+        }
+      }
+    }
+
+    // Step 3: Use flowKey for auth
+    const activeFlowKey = flowKey;
+    if (!activeFlowKey) {
+      sendToAgent({ id, status: 503, error: 'NO_FLOW_KEY' });
+      if (hasCaptcha) { metrics.failedCount++; metrics.lastError = 'NO_FLOW_KEY'; }
+      chrome.storage.local.set({ metrics });
+      updateRequestLog(logId, { status: 'failed', error: 'NO_FLOW_KEY' });
+      setState('idle');
+      return;
+    }
+
+    const fetchHeaders = { ...(headers || {}) };
+    fetchHeaders['authorization'] = `Bearer ${activeFlowKey}`;
+
+    // Step 4: Make the API call from browser context
+    const response = await fetch(url, {
+      method: method || 'POST',
+      headers: fetchHeaders,
+      credentials: 'include',
+      body: method === 'GET' ? undefined : JSON.stringify(finalBody),
+    });
+
+    let responseData;
+    const responseText = await response.text();
+    try {
+      responseData = JSON.parse(responseText);
+    } catch {
+      responseData = responseText;
+    }
+
+    sendToAgent({
+      id,
+      status: response.status,
+      data: responseData,
+    });
+
+    const responseSummary = responseText ? responseText.slice(0, 300) : null;
+    if (response.ok) {
+      if (hasCaptcha) { metrics.successCount++; metrics.lastError = null; }
+      updateRequestLog(logId, { status: 'success', httpStatus: response.status, responseSummary });
+    } else {
+      if (hasCaptcha) { metrics.failedCount++; metrics.lastError = `API_${response.status}`; }
+      updateRequestLog(logId, { status: 'failed', error: `API_${response.status}`, httpStatus: response.status, responseSummary });
+    }
+  } catch (e) {
+    sendToAgent({
+      id,
+      status: 500,
+      error: e.message || 'API_REQUEST_FAILED',
+    });
+    if (hasCaptcha) { metrics.failedCount++; metrics.lastError = e.message; }
+    updateRequestLog(logId, { status: 'failed', error: e.message || 'API_REQUEST_FAILED' });
+  }
+
+  chrome.storage.local.set({ metrics });
+  setState('idle');
+}
+
+// ─── State & Popup ──────────────────────────────────────────
+
+function setState(newState) {
+  state = newState;
+  const badges = { idle: '●', running: '▶', off: '○' };
+  const colors = { idle: '#22c55e', running: '#f59e0b', off: '#6b7280' };
+  chrome.action.setBadgeText({ text: badges[state] || '' });
+  chrome.action.setBadgeBackgroundColor({ color: colors[state] || '#000' });
+  broadcastStatus();
+}
+
+function broadcastStatus() {
+  chrome.runtime.sendMessage({ type: 'STATUS_PUSH' }).catch(() => {});
+}
+
+chrome.runtime.onMessage.addListener((msg, _, reply) => {
+  if (msg.type === 'STATUS') {
+    reply({
+      connected: ws?.readyState === WebSocket.OPEN,
+      agentConnected: ws?.readyState === WebSocket.OPEN,
+      flowKeyPresent: !!flowKey,
+      manualDisconnect,
+      tokenAge: metrics.tokenCapturedAt ? Date.now() - metrics.tokenCapturedAt : null,
+      metrics: {
+        requestCount: metrics.requestCount,
+        successCount: metrics.successCount,
+        failedCount: metrics.failedCount,
+        lastError: metrics.lastError,
+      },
+      state,
+    });
+  }
+
+  if (msg.type === 'DISCONNECT') {
+    manualDisconnect = true;
+    if (ws) ws.close();
+    reply({ ok: true });
+    return true;
+  }
+
+  if (msg.type === 'RECONNECT') {
+    manualDisconnect = false;
+    connectToAgent();
+    reply({ ok: true });
+    return true;
+  }
+
+  if (msg.type === 'REQUEST_LOG') {
+    reply({ log: requestLog });
+    return true;
+  }
+
+  if (msg.type === 'OPEN_FLOW_TAB') {
+    chrome.tabs.query({
+      url: ['https://labs.google/fx/tools/flow*', 'https://labs.google/fx/*/tools/flow*'],
+    }).then((tabs) => {
+      if (tabs.length) {
+        chrome.tabs.update(tabs[0].id, { active: true });
+        reply({ ok: true, tabId: tabs[0].id });
+      } else {
+        chrome.tabs.create({ url: 'https://labs.google/fx/tools/flow' })
+          .then((tab) => reply({ ok: true, tabId: tab.id }))
+          .catch((e) => reply({ error: e.message }));
+      }
+    }).catch((e) => reply({ error: e.message }));
+    return true;
+  }
+
+  if (msg.type === 'REFRESH_TOKEN') {
+    captureTokenFromFlowTab()
+      .then(() => reply({ ok: true }))
+      .catch((e) => reply({ error: e.message }));
+    return true;
+  }
+
+  if (msg.type === 'TEST_CAPTCHA') {
+    solveCaptcha(`test-${Date.now()}`, msg.pageAction || 'IMAGE_GENERATION')
+      .then((r) => reply(r))
+      .catch((e) => reply({ error: e.message }));
+    return true;
+  }
+
+  if (msg.type === 'TRPC_MEDIA_URLS') {
+    handleTrpcMediaUrls(msg.trpcUrl, msg.body);
+    reply({ ok: true });
+    return true;
+  }
+
+  if (msg.type === 'SNIFFED_AISANDBOX_REQUEST') {
+    console.log('[Flow Agent] SNIFFED aisandbox request:', msg.url);
+    fetch('http://127.0.0.1:8100/api/ext/callback', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        type: 'sniffed_video_request',
+        url: msg.url,
+        method: msg.method,
+        payload: msg.payload,
+        timestamp: msg.timestamp,
+      }),
+    }).catch((e) => console.error('[Flow Agent] Failed to forward sniffed request:', e));
+    reply({ ok: true });
+    return true;
+  }
+
+  return true;
+});
+
+// ─── TRPC Media URL Extractor ──────────────────────────────
+
+function handleTrpcMediaUrls(trpcUrl, bodyText) {
+  try {
+    // Extract all fresh GCS signed URLs
+    const urlRegex = /https:\/\/storage\.googleapis\.com\/ai-sandbox-videofx\/(?:image|video)\/[0-9a-f-]{36}\?[^"'\s]+/g;
+    const matches = bodyText.match(urlRegex) || [];
+    if (!matches.length) return;
+
+    // Deduplicate and parse
+    const urlMap = {};
+    for (const rawUrl of matches) {
+      // Unescape JSON-escaped URLs
+      const url = rawUrl.replace(/\\u0026/g, '&').replace(/\\/g, '');
+      const mediaMatch = url.match(/\/(image|video)\/([0-9a-f-]{36})\?/);
+      if (mediaMatch) {
+        const [, mediaType, mediaId] = mediaMatch;
+        // Keep last occurrence (freshest)
+        urlMap[mediaId] = { mediaType, url, mediaId };
+      }
+    }
+
+    const entries = Object.values(urlMap);
+    if (!entries.length) return;
+
+    console.log(`[Flow Agent] Captured ${entries.length} fresh media URLs from TRPC`);
+    // URL refresh is silent — don't show in request log
+
+    // Forward to agent for DB update
+    if (ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({
+        type: 'media_urls_refresh',
+        urls: entries,
+      }));
+    }
+  } catch (e) {
+    console.error('[Flow Agent] Failed to extract TRPC media URLs:', e);
+  }
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// ─── Human-like Telemetry ──────────────────────────────────
+// Periodically send tracking events to Google's analytics endpoints
+// to mimic normal browser behavior.
+
+const _UA = navigator.userAgent;
+let _telemetrySessionId = `;${Date.now()}`;
+
+function _rand(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; }
+
+function _buildBatchLogPayload() {
+  const events = [];
+  const types = ['FLOW_IMAGE_LATENCY', 'FLOW_VIDEO_LATENCY'];
+  const count = _rand(1, 3);
+  for (let i = 0; i < count; i++) {
+    events.push({
+      event: types[_rand(0, types.length - 1)],
+      eventProperties: [
+        { key: 'CURRENT_TIME_MS', doubleValue: Date.now() },
+        { key: 'DURATION_MS', doubleValue: _rand(150, 800) },
+        { key: 'USER_AGENT', stringValue: _UA },
+        { key: 'IS_DESKTOP', booleanValue: true },
+      ],
+      eventMetadata: { sessionId: _telemetrySessionId },
+      eventTime: new Date().toISOString(),
+    });
+  }
+  return { appEvents: events };
+}
+
+function _buildFrontendEventsPayload() {
+  const eventTypes = [
+    'FLOW_IMAGE_LATENCY', 'FLOW_VIDEO_LATENCY', 'GRID_SCROLL_DEPTH',
+    'FLOW_PROJECT_OPEN', 'FLOW_SCENE_VIEW',
+  ];
+  const count = _rand(1, 4);
+  const events = [];
+  for (let i = 0; i < count; i++) {
+    const et = eventTypes[_rand(0, eventTypes.length - 1)];
+    const params = {
+      USER_AGENT: { '@type': 'type.googleapis.com/google.protobuf.StringValue', value: _UA },
+      IS_DESKTOP: { '@type': 'type.googleapis.com/google.protobuf.StringValue', value: 'true' },
+    };
+    if (et.includes('LATENCY')) {
+      params.CURRENT_TIME_MS = { '@type': 'type.googleapis.com/google.protobuf.StringValue', value: String(Date.now()) };
+      params.DURATION_MS = { '@type': 'type.googleapis.com/google.protobuf.StringValue', value: String(_rand(100, 600)) };
+    }
+    if (et === 'GRID_SCROLL_DEPTH') {
+      params.MEDIA_GENERATION_PAYGATE_TIER = { '@type': 'type.googleapis.com/google.protobuf.StringValue', value: 'PAYGATE_TIER_TWO' };
+    }
+    events.push({
+      eventType: et,
+      metadata: {
+        sessionId: _telemetrySessionId,
+        createTime: new Date().toISOString(),
+        additionalParams: params,
+      },
+    });
+  }
+  return { events };
+}
+
+async function sendTelemetry() {
+  if (!flowKey || state === 'off') return;
+
+  const headers = {
+    'Content-Type': 'text/plain;charset=UTF-8',
+    'authorization': `Bearer ${flowKey}`,
+  };
+
+  // Telemetry is silent — don't show in request log
+  try {
+    if (Math.random() < 0.5) {
+      await fetch(`https://aisandbox-pa.googleapis.com/v1:batchLog`, {
+        method: 'POST', headers, credentials: 'include',
+        body: JSON.stringify(_buildBatchLogPayload()),
+      });
+    } else {
+      await fetch(`https://aisandbox-pa.googleapis.com/v1/flow:batchLogFrontendEvents`, {
+        method: 'POST', headers, credentials: 'include',
+        body: JSON.stringify(_buildFrontendEventsPayload()),
+      });
+    }
+  } catch {}
+}
+
+// Send telemetry at random intervals (45-120s) to look organic
+function scheduleTelemetry() {
+  const delay = _rand(45, 120) * 1000;
+  setTimeout(async () => {
+    await sendTelemetry();
+    scheduleTelemetry(); // reschedule with new random interval
+  }, delay);
+}
+
+// Refresh session ID every ~30min like a real user
+setInterval(() => { _telemetrySessionId = `;${Date.now()}`; }, _rand(25, 35) * 60 * 1000);
+
+scheduleTelemetry();
+
+console.log('[Flow Agent] Extension loaded');

flow-agent/extension/content.js

@@ -0,0 +1,91 @@
+/**
+ * Content script — bridge between background.js and injected.js
+ * Injects injected.js into MAIN world to access window.grecaptcha
+ */
+(function () {
+  const s = document.createElement('script');
+  s.src = chrome.runtime.getURL('injected.js');
+  s.onload = () => s.remove();
+  (document.head || document.documentElement).appendChild(s);
+})();
+
+chrome.runtime.onMessage.addListener((msg, _, reply) => {
+  if (msg.type !== 'GET_CAPTCHA') return;
+
+  const { requestId, pageAction } = msg;
+
+  const handler = (e) => {
+    if (e.detail?.requestId === requestId) {
+      window.removeEventListener('CAPTCHA_RESULT', handler);
+      clearTimeout(timer);
+      reply({ token: e.detail.token, error: e.detail.error });
+    }
+  };
+
+  const timer = setTimeout(() => {
+    window.removeEventListener('CAPTCHA_RESULT', handler);
+    reply({ error: 'CONTENT_TIMEOUT' });
+  }, 25000);
+
+  window.addEventListener('CAPTCHA_RESULT', handler);
+
+  window.dispatchEvent(new CustomEvent('GET_CAPTCHA', {
+    detail: { requestId, pageAction },
+  }));
+
+  return true; // keep channel open for async reply
+});
+
+// ─── TRPC Media URL Monitor ─────────────────────────────────
+// Forward intercepted TRPC responses with media URLs to background.js
+window.addEventListener('TRPC_MEDIA_URLS', (e) => {
+  const { url, body } = e.detail || {};
+  if (!body) return;
+  chrome.runtime.sendMessage({
+    type: 'TRPC_MEDIA_URLS',
+    trpcUrl: url,
+    body,
+  }).catch(() => {});
+});
+
+// ─── Aisandbox Request Sniffer (via postMessage from MAIN world) ──
+window.addEventListener('message', (e) => {
+  if (e.data?.type !== '__FLOWKIT_SNIFF__') return;
+  const { url, body, method } = e.data;
+  if (!url) return;
+  chrome.runtime.sendMessage({
+    type: 'SNIFFED_AISANDBOX_REQUEST',
+    url,
+    method,
+    payload: body,
+    timestamp: Date.now(),
+  }).catch(() => {});
+});
+
+// ─── Video Upload Relay ─────────────────────────────────────
+chrome.runtime.onMessage.addListener((msg, _, reply) => {
+  if (msg.type !== 'UPLOAD_VIDEO') return;
+
+  const { requestId, videoBase64, projectId } = msg;
+
+  const handler = (e) => {
+    if (e.detail?.requestId === requestId) {
+      window.removeEventListener('UPLOAD_VIDEO_RESULT', handler);
+      clearTimeout(timer);
+      reply(e.detail);
+    }
+  };
+
+  const timer = setTimeout(() => {
+    window.removeEventListener('UPLOAD_VIDEO_RESULT', handler);
+    reply({ error: 'UPLOAD_TIMEOUT' });
+  }, 120000); // 2 min timeout for large uploads
+
+  window.addEventListener('UPLOAD_VIDEO_RESULT', handler);
+
+  window.dispatchEvent(new CustomEvent('UPLOAD_VIDEO', {
+    detail: { requestId, videoBase64, projectId },
+  }));
+
+  return true; // keep channel open for async reply
+});

flow-agent/extension/injected.js

@@ -0,0 +1,163 @@
+/**
+ * Injected into MAIN world on labs.google — has access to window.grecaptcha
+ * Also intercepts TRPC fetch responses to capture fresh signed media URLs.
+ */
+const SITE_KEY = '6LdsFiUsAAAAAIjVDZcuLhaHiDn5nnHVXVRQGeMV';
+
+// ─── XHR Interceptor (for file uploads) ─────────────────────
+const _xhrOpen = XMLHttpRequest.prototype.open;
+const _xhrSend = XMLHttpRequest.prototype.send;
+XMLHttpRequest.prototype.open = function (method, url, ...rest) {
+  this.__sniffUrl = url;
+  this.__sniffMethod = method;
+  return _xhrOpen.call(this, method, url, ...rest);
+};
+XMLHttpRequest.prototype.send = function (body) {
+  try {
+    const url = this.__sniffUrl || '';
+    if (url.includes('googleapis.com') || url.includes('labs.google') || url.includes('storage.google')) {
+      window.postMessage({
+        type: '__FLOWKIT_SNIFF__',
+        url,
+        body: typeof body === 'string' ? body : `(binary ${body?.size || body?.byteLength || '?'} bytes)`,
+        method: this.__sniffMethod || 'POST',
+      }, '*');
+    }
+  } catch {}
+  return _xhrSend.call(this, body);
+};
+
+// ─── TRPC Response Monitor ─────────────────────────────────
+// Monkey-patch fetch to intercept TRPC responses containing media URLs.
+// Fresh signed GCS URLs are extracted and forwarded to the agent.
+
+const _originalFetch = window.fetch;
+window.fetch = async function (...args) {
+  try {
+    const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
+
+    // ─── SNIFF ALL outgoing requests (catch upload) ─────────
+    {
+      let bodyText = '';
+      if (args[1]?.body) {
+        const b = args[1].body;
+        if (typeof b === 'string') bodyText = b.length > 5000 ? b.slice(0, 200) + `...(${b.length} chars)` : b;
+        else if (b instanceof FormData) bodyText = `(FormData: ${[...b.keys()].join(', ')})`;
+        else if (b instanceof Blob) bodyText = `(Blob ${b.size} bytes, type=${b.type})`;
+        else if (b instanceof ArrayBuffer) bodyText = `(ArrayBuffer ${b.byteLength} bytes)`;
+        else if (b instanceof ReadableStream) bodyText = '(ReadableStream)';
+        else bodyText = JSON.stringify(b)?.slice(0, 2000) || '(unknown)';
+      }
+      window.postMessage({
+        type: '__FLOWKIT_SNIFF__',
+        url, body: bodyText, method: args[1]?.method || 'GET',
+      }, '*');
+    }
+  } catch {}
+
+  const response = await _originalFetch.apply(this, args);
+  try {
+    const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
+    // Only intercept TRPC calls on labs.google that return project/flow data
+    if (url.includes('/fx/api/trpc/') && response.ok) {
+      const clone = response.clone();
+      clone.text().then(text => {
+        if (text.includes('storage.googleapis.com/ai-sandbox-videofx/')) {
+          window.dispatchEvent(new CustomEvent('TRPC_MEDIA_URLS', {
+            detail: { url, body: text },
+          }));
+        }
+      }).catch(() => {});
+    }
+  } catch {}
+  return response;
+};
+
+
+window.addEventListener('GET_CAPTCHA', async ({ detail }) => {
+  const { requestId, pageAction } = detail;
+  try {
+    await waitForGrecaptcha();
+    const token = await window.grecaptcha.enterprise.execute(SITE_KEY, {
+      action: pageAction,
+    });
+    window.dispatchEvent(new CustomEvent('CAPTCHA_RESULT', {
+      detail: { requestId, token },
+    }));
+  } catch (e) {
+    window.dispatchEvent(new CustomEvent('CAPTCHA_RESULT', {
+      detail: { requestId, error: e.message },
+    }));
+  }
+});
+
+function waitForGrecaptcha(timeout = 10000) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const check = () => {
+      if (window.grecaptcha?.enterprise?.execute) return resolve();
+      if (Date.now() - start > timeout) return reject(new Error('grecaptcha not available'));
+      setTimeout(check, 200);
+    };
+    check();
+  });
+}
+
+// ─── Video Upload Handler ───────────────────────────────────
+window.addEventListener('UPLOAD_VIDEO', async ({ detail }) => {
+  const { requestId, videoBase64, projectId } = detail;
+  try {
+    // Convert base64 to Blob
+    const byteChars = atob(videoBase64);
+    const byteArray = new Uint8Array(byteChars.length);
+    for (let i = 0; i < byteChars.length; i++) {
+      byteArray[i] = byteChars.charCodeAt(i);
+    }
+    const blob = new Blob([byteArray], { type: 'video/mp4' });
+
+    // Step 1: POST start — get session URL
+    const startResp = await _originalFetch('/fx/api/upload-video?action=start', {
+      method: 'POST',
+      credentials: 'include',
+      headers: {
+        'X-Upload-Project-Id': projectId || '',
+        'X-Upload-Content-Type': 'video/mp4',
+        'X-Upload-Content-Length': blob.size.toString(),
+      },
+    });
+    const sessionUrl = startResp.headers.get('X-Upload-Session-Url') || '';
+    const startData = await startResp.json().catch(() => ({}));
+    // sessionUrl may be in header OR in response body
+    const finalSessionUrl = sessionUrl || startData.sessionUrl || '';
+    startData._sessionUrl = finalSessionUrl;
+    startData._status = startResp.status;
+
+    if (!finalSessionUrl) {
+      window.dispatchEvent(new CustomEvent('UPLOAD_VIDEO_RESULT', {
+        detail: { requestId, error: 'NO_SESSION_URL', startData },
+      }));
+      return;
+    }
+
+    // Step 2: PUT directly to GCS session URL with resumable upload headers
+    const uploadResp = await _originalFetch(finalSessionUrl, {
+      method: 'PUT',
+      body: blob,
+      headers: {
+        'Content-Type': 'video/mp4',
+        'X-Goog-Upload-Command': 'upload, finalize',
+        'X-Goog-Upload-Offset': '0',
+      },
+    });
+    const uploadData = await uploadResp.json().catch(() => ({}));
+    uploadData._status = uploadResp.status;
+
+    window.dispatchEvent(new CustomEvent('UPLOAD_VIDEO_RESULT', {
+      detail: { requestId, startData, uploadData, status: uploadResp.status },
+    }));
+  } catch (e) {
+    window.dispatchEvent(new CustomEvent('UPLOAD_VIDEO_RESULT', {
+      detail: { requestId, error: e.message },
+    }));
+  }
+});

flow-agent/extension/manifest.json

@@ -0,0 +1,59 @@
+{
+  "manifest_version": 3,
+  "name": "Flow Agent",
+  "version": "1.0.0",
+  "description": "Automate Google Flow — T2V, V2V, I2V video + T2I, I2I unlimited image generation from terminal",
+  "icons": {
+    "16": "icon16.png",
+    "48": "icon48.png",
+    "128": "icon128.png"
+  },
+  "permissions": ["storage", "alarms", "tabs", "webRequest", "scripting", "declarativeNetRequest", "sidePanel"],
+  "host_permissions": [
+    "https://labs.google/*",
+    "https://aisandbox-pa.googleapis.com/*",
+    "https://aisandbox-pa.sandbox.googleapis.com/*",
+    "https://storage.googleapis.com/*",
+    "http://127.0.0.1:8100/*"
+  ],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "content_scripts": [
+    {
+      "matches": [
+        "https://labs.google/fx/tools/flow*",
+        "https://labs.google/fx/*/tools/flow*"
+      ],
+      "js": ["content.js"],
+      "run_at": "document_start"
+    }
+  ],
+  "web_accessible_resources": [
+    {
+      "resources": ["injected.js"],
+      "matches": ["https://labs.google/*"]
+    }
+  ],
+  "declarative_net_request": {
+    "rule_resources": [
+      {
+        "id": "referer_rules",
+        "enabled": true,
+        "path": "rules.json"
+      }
+    ]
+  },
+  "side_panel": {
+    "default_path": "side_panel.html"
+  },
+  "action": {
+    "default_popup": "popup.html",
+    "default_title": "Flow Agent",
+    "default_icon": {
+      "16": "icon16.png",
+      "48": "icon48.png",
+      "128": "icon128.png"
+    }
+  }
+}

flow-agent/extension/popup.html

@@ -0,0 +1,337 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8">
+  <title>Flow Agent</title>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap" rel="stylesheet">
+  <style>
+    *,
+    *::before,
+    *::after {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    :root {
+      --bg: #08090e;
+      --surface: #0e1018;
+      --card: #141622;
+      --card-hover: #1a1d2e;
+      --border: #1e2235;
+      --border-glow: #2a3050;
+      --accent: #6366f1;
+      --accent-soft: #818cf8;
+      --accent-bg: rgba(99, 102, 241, 0.08);
+      --green: #10b981;
+      --red: #f43f5e;
+      --yellow: #f59e0b;
+      --cyan: #22d3ee;
+      --text: #e8eaf0;
+      --text-dim: #9ca3af;
+      --muted: #6b7280;
+      --font: 'Inter', -apple-system, sans-serif;
+      --mono: 'SF Mono', 'Fira Code', monospace;
+      --radius: 8px;
+    }
+
+    html,
+    body {
+      width: 360px;
+      min-height: 200px;
+      background: var(--bg);
+      color: var(--text);
+      font-family: var(--font);
+      font-size: 12px;
+      line-height: 1.5;
+      -webkit-font-smoothing: antialiased;
+    }
+
+    header {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      padding: 12px 14px 10px;
+      border-bottom: 1px solid var(--border);
+      background: linear-gradient(180deg, rgba(99, 102, 241, 0.06) 0%, var(--surface) 100%);
+      position: relative;
+    }
+
+    header::after {
+      content: '';
+      position: absolute;
+      bottom: -1px;
+      left: 14px;
+      right: 14px;
+      height: 1px;
+      background: linear-gradient(90deg, transparent, rgba(99, 102, 241, 0.25), transparent);
+    }
+
+    .logo {
+      width: 24px;
+      height: 24px;
+      border-radius: 6px;
+      background: linear-gradient(135deg, var(--accent), #a855f7);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-weight: 800;
+      font-size: 12px;
+      color: #fff;
+      box-shadow: 0 2px 6px rgba(99, 102, 241, 0.3);
+    }
+
+    .header-title {
+      flex: 1;
+      font-size: 13px;
+      font-weight: 700;
+      background: linear-gradient(135deg, #e0e7ff, #c7d2fe);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+    }
+
+    #btn-panel {
+      padding: 5px 12px;
+      font-family: var(--font);
+      font-size: 10px;
+      font-weight: 600;
+      letter-spacing: 0.02em;
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      background: linear-gradient(135deg, var(--accent), #7c3aed);
+      color: #fff;
+      cursor: pointer;
+      transition: all 0.2s;
+      box-shadow: 0 2px 6px rgba(99, 102, 241, 0.2);
+    }
+
+    #btn-panel:hover {
+      background: linear-gradient(135deg, #818cf8, #8b5cf6);
+      box-shadow: 0 3px 10px rgba(99, 102, 241, 0.3);
+      transform: translateY(-1px);
+    }
+
+    .log-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 8px 14px 6px;
+      font-size: 9px;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.1em;
+      color: var(--muted);
+      background: var(--surface);
+      border-bottom: 1px solid var(--border);
+    }
+
+    #log-count {
+      background: var(--accent-bg);
+      border: 1px solid rgba(99, 102, 241, 0.15);
+      border-radius: 10px;
+      padding: 1px 7px;
+      font-size: 10px;
+      font-weight: 700;
+      color: var(--accent-soft);
+    }
+
+    #log-list {
+      max-height: 440px;
+      overflow-y: auto;
+      scrollbar-width: thin;
+      scrollbar-color: var(--border) transparent;
+    }
+
+    #log-list::-webkit-scrollbar {
+      width: 4px;
+    }
+
+    #log-list::-webkit-scrollbar-track {
+      background: transparent;
+    }
+
+    #log-list::-webkit-scrollbar-thumb {
+      background: var(--border);
+      border-radius: 2px;
+    }
+
+    .log-empty {
+      padding: 28px 14px;
+      text-align: center;
+      color: var(--muted);
+      font-size: 11px;
+    }
+
+    .log-empty::before {
+      content: '📋';
+      display: block;
+      font-size: 20px;
+      margin-bottom: 6px;
+      opacity: 0.4;
+    }
+
+    .entry {
+      border-bottom: 1px solid rgba(30, 34, 53, 0.6);
+    }
+
+    .entry-row {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      padding: 7px 14px;
+      cursor: pointer;
+      transition: background 0.15s;
+      user-select: none;
+    }
+
+    .entry-row:hover {
+      background: var(--accent-bg);
+    }
+
+    .entry-id {
+      font-family: var(--mono);
+      font-size: 9px;
+      color: var(--muted);
+      min-width: 54px;
+      flex-shrink: 0;
+    }
+
+    .entry-type {
+      flex: 1;
+      font-size: 11px;
+      font-weight: 700;
+      color: var(--cyan);
+      letter-spacing: 0.02em;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    .entry-time {
+      font-family: var(--mono);
+      font-size: 9px;
+      color: var(--text-dim);
+      flex-shrink: 0;
+      font-variant-numeric: tabular-nums;
+    }
+
+    .badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 2px;
+      padding: 2px 6px;
+      border-radius: 4px;
+      font-size: 9px;
+      font-weight: 700;
+      flex-shrink: 0;
+    }
+
+    .badge-ok {
+      background: rgba(16, 185, 129, 0.1);
+      color: var(--green);
+    }
+
+    .badge-fail {
+      background: rgba(244, 63, 94, 0.1);
+      color: var(--red);
+    }
+
+    .badge-proc {
+      background: rgba(245, 158, 11, 0.1);
+      color: var(--yellow);
+    }
+
+    .expand-icon {
+      font-size: 9px;
+      color: var(--muted);
+      flex-shrink: 0;
+      transition: transform 0.2s ease;
+    }
+
+    .entry.open .expand-icon {
+      transform: rotate(90deg);
+    }
+
+    .entry-details {
+      display: none;
+      padding: 0 14px 10px;
+      background: var(--surface);
+    }
+
+    .entry.open .entry-details {
+      display: block;
+    }
+
+    .detail-section {
+      margin-top: 6px;
+    }
+
+    .detail-label {
+      font-size: 9px;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: var(--muted);
+      margin-bottom: 2px;
+    }
+
+    .detail-value {
+      font-family: var(--mono);
+      font-size: 9px;
+      color: var(--text);
+      background: var(--card);
+      border: 1px solid var(--border);
+      border-radius: 4px;
+      padding: 5px 8px;
+      word-break: break-all;
+      white-space: pre-wrap;
+      max-height: 80px;
+      overflow-y: auto;
+    }
+
+    .detail-value.url {
+      color: var(--accent-soft);
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      max-height: none;
+    }
+
+    .detail-error {
+      color: var(--red);
+    }
+
+    .footer {
+      padding: 10px 14px;
+      border-top: 1px solid var(--border);
+      background: var(--surface);
+      font-size: 10px;
+      color: var(--muted);
+      text-align: center;
+    }
+  </style>
+</head>
+
+<body>
+  <header>
+    <img src="icon48.png" style="width:24px;height:24px;border-radius:6px;box-shadow:0 2px 6px rgba(99,102,241,0.3)">
+    <div class="header-title">Flow Agent</div>
+    <button id="btn-panel">Side Panel</button>
+  </header>
+
+  <div class="log-header">
+    Recent Requests
+    <span id="log-count">0</span>
+  </div>
+
+  <div id="log-list">
+    <div class="log-empty">No requests yet</div>
+  </div>
+
+  <div class="footer">Click a row to expand details</div>
+
+  <script src="popup.js"></script>
+</body>
+
+</html>

flow-agent/extension/popup.js

@@ -0,0 +1,138 @@
+const TYPE_LABELS = {
+  GENERATE_IMAGE:           'GEN IMAGE',
+  REGENERATE_IMAGE:         'REGEN IMAGE',
+  EDIT_IMAGE:               'EDIT IMAGE',
+  GENERATE_CHARACTER_IMAGE: 'GEN REF',
+  REGENERATE_CHARACTER_IMAGE: 'REGEN REF',
+  EDIT_CHARACTER_IMAGE:     'EDIT REF',
+  GENERATE_VIDEO:           'GEN VIDEO',
+  GENERATE_VIDEO_REFS:      'GEN VIDEO FROM REFS',
+  UPSCALE_VIDEO:            'UPSCALE VIDEO',
+  GEN_IMG:                  'GEN IMAGE',
+  GEN_VID:                  'GEN VIDEO',
+  GEN_VID_REF:              'GEN VIDEO FROM REFS',
+  UPSCALE:                  'UPSCALE VIDEO',
+  TRACKING:                 'TRACKING',
+  URL_REFRESH:              'URL REFRESH',
+};
+
+function formatType(type) {
+  if (!type) return '—';
+  return TYPE_LABELS[type] || type.slice(0, 12).toUpperCase();
+}
+
+function formatTime(iso) {
+  if (!iso) return '—';
+  try {
+    const d = new Date(iso);
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    return `${hh}:${mm}:${ss}`;
+  } catch {
+    return '—';
+  }
+}
+
+function escHtml(str) {
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function badgeHtml(status) {
+  if (status === 'COMPLETED' || status === 'success') {
+    return '<span class="badge badge-ok">&#10003; done</span>';
+  } else if (status === 'FAILED' || status === 'failed' || (typeof status === 'number' && status >= 400)) {
+    return '<span class="badge badge-fail">&#10007; fail</span>';
+  } else if (status === 'PROCESSING') {
+    return '<span class="badge badge-proc">&#9203; gen...</span>';
+  } else {
+    return '<span class="badge badge-proc">&#9203; sent</span>';
+  }
+}
+
+function renderLog(entries) {
+  const list = document.getElementById('log-list');
+  const countEl = document.getElementById('log-count');
+
+  if (!entries || entries.length === 0) {
+    list.innerHTML = '<div class="log-empty">No requests yet</div>';
+    countEl.textContent = '0';
+    return;
+  }
+
+  countEl.textContent = entries.length;
+
+  list.innerHTML = entries.map((entry, i) => {
+    const shortId = entry.id ? String(entry.id).slice(0, 8) : '—';
+    const type = formatType(entry.type || entry.method);
+    const time = formatTime(entry.time || entry.timestamp);
+    const status = entry.status || 'pending';
+    const error = entry.error || '';
+
+    const urlDisplay = entry.url
+      ? `<div class="detail-section">
+           <div class="detail-label">URL</div>
+           <div class="detail-value url" title="${escHtml(entry.url)}">${escHtml(entry.url)}</div>
+         </div>`
+      : '';
+
+    const payloadDisplay = entry.payloadSummary
+      ? `<div class="detail-section">
+           <div class="detail-label">Payload</div>
+           <div class="detail-value">${escHtml(entry.payloadSummary)}</div>
+         </div>`
+      : '';
+
+    const responseDisplay = entry.responseSummary
+      ? `<div class="detail-section">
+           <div class="detail-label">Response${entry.httpStatus ? ` (${entry.httpStatus})` : ''}</div>
+           <div class="detail-value">${escHtml(entry.responseSummary)}</div>
+         </div>`
+      : '';
+
+    const errorDisplay = error
+      ? `<div class="detail-section">
+           <div class="detail-label">Error</div>
+           <div class="detail-value detail-error">${escHtml(error)}</div>
+         </div>`
+      : '';
+
+    const hasDetails = entry.url || entry.payloadSummary || entry.responseSummary || error;
+
+    return `<div class="entry" data-idx="${i}">
+      <div class="entry-row">
+        <span class="entry-id">${escHtml(shortId)}</span>
+        <span class="entry-type">${escHtml(type)}</span>
+        <span class="entry-time">${escHtml(time)}</span>
+        ${badgeHtml(status)}
+        ${hasDetails ? '<span class="expand-icon">&#9654;</span>' : '<span class="expand-icon" style="visibility:hidden">&#9654;</span>'}
+      </div>
+      ${hasDetails ? `<div class="entry-details">${urlDisplay}${payloadDisplay}${responseDisplay}${errorDisplay}</div>` : ''}
+    </div>`;
+  }).join('');
+
+  // Toggle expand on row click
+  list.querySelectorAll('.entry-row').forEach((row) => {
+    row.addEventListener('click', () => {
+      const entry = row.closest('.entry');
+      if (entry.querySelector('.entry-details')) {
+        entry.classList.toggle('open');
+      }
+    });
+  });
+}
+
+document.getElementById('btn-panel').addEventListener('click', () => {
+  chrome.windows.getCurrent((win) => {
+    chrome.sidePanel.open({ windowId: win.id });
+  });
+});
+
+chrome.runtime.sendMessage({ type: 'REQUEST_LOG' }, (data) => {
+  if (chrome.runtime.lastError) return;
+  if (data && data.log) renderLog(data.log);
+});

flow-agent/extension/rules.json

@@ -0,0 +1,25 @@
+[
+  {
+    "id": 1,
+    "priority": 1,
+    "action": {
+      "type": "modifyHeaders",
+      "requestHeaders": [
+        {
+          "header": "Referer",
+          "operation": "set",
+          "value": "https://labs.google/"
+        },
+        {
+          "header": "Origin",
+          "operation": "set",
+          "value": "https://labs.google"
+        }
+      ]
+    },
+    "condition": {
+      "urlFilter": "aisandbox-pa.googleapis.com",
+      "resourceTypes": ["xmlhttprequest"]
+    }
+  }
+]

flow-agent/extension/side_panel.html

@@ -0,0 +1,840 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8">
+  <title>Flow Agent</title>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap" rel="stylesheet">
+  <style>
+    *,
+    *::before,
+    *::after {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    :root {
+      --bg: #08090e;
+      --surface: #0e1018;
+      --card: #141622;
+      --card-hover: #1a1d2e;
+      --border: #1e2235;
+      --border-glow: #2a3050;
+      --accent: #6366f1;
+      --accent-soft: #818cf8;
+      --accent-bg: rgba(99, 102, 241, 0.08);
+      --accent-glow: rgba(99, 102, 241, 0.25);
+      --green: #10b981;
+      --green-bg: rgba(16, 185, 129, 0.1);
+      --red: #f43f5e;
+      --red-bg: rgba(244, 63, 94, 0.1);
+      --yellow: #f59e0b;
+      --yellow-bg: rgba(245, 158, 11, 0.1);
+      --cyan: #22d3ee;
+      --text: #e8eaf0;
+      --text-dim: #9ca3af;
+      --muted: #6b7280;
+      --font: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+      --mono: 'SF Mono', 'Fira Code', 'Cascadia Code', monospace;
+      --radius: 10px;
+      --radius-sm: 6px;
+    }
+
+    html,
+    body {
+      height: 100%;
+      margin: 0;
+    }
+
+    body {
+      width: 100%;
+      min-width: 280px;
+      background: var(--bg);
+      color: var(--text);
+      font-family: var(--font);
+      font-size: 13px;
+      line-height: 1.5;
+      display: flex;
+      flex-direction: column;
+      -webkit-font-smoothing: antialiased;
+    }
+
+    /* ── Header ─────────────────────────────────── */
+    header {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      padding: 14px 16px 12px;
+      background: linear-gradient(180deg, rgba(99, 102, 241, 0.06) 0%, var(--surface) 100%);
+      border-bottom: 1px solid var(--border);
+      position: relative;
+    }
+
+    header::after {
+      content: '';
+      position: absolute;
+      bottom: -1px;
+      left: 16px;
+      right: 16px;
+      height: 1px;
+      background: linear-gradient(90deg, transparent, var(--accent-glow), transparent);
+    }
+
+    .logo {
+      width: 28px;
+      height: 28px;
+      border-radius: 8px;
+      background: linear-gradient(135deg, var(--accent), #a855f7);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-weight: 800;
+      font-size: 14px;
+      color: #fff;
+      box-shadow: 0 2px 8px rgba(99, 102, 241, 0.3);
+      flex-shrink: 0;
+    }
+
+    .header-info {
+      flex: 1;
+    }
+
+    .header-title {
+      font-size: 14px;
+      font-weight: 700;
+      letter-spacing: -0.01em;
+      background: linear-gradient(135deg, #e0e7ff, #c7d2fe);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+    }
+
+    .header-sub {
+      font-size: 10px;
+      color: var(--muted);
+      letter-spacing: 0.03em;
+    }
+
+    /* Connection indicator */
+    #conn-dot {
+      width: 10px;
+      height: 10px;
+      border-radius: 50%;
+      background: var(--red);
+      transition: all 0.4s ease;
+      flex-shrink: 0;
+      position: relative;
+    }
+
+    #conn-dot.on {
+      background: var(--green);
+      box-shadow: 0 0 8px 2px rgba(16, 185, 129, 0.4);
+      animation: pulse-glow 2.5s ease-in-out infinite;
+    }
+
+    @keyframes pulse-glow {
+
+      0%,
+      100% {
+        box-shadow: 0 0 6px 1px rgba(16, 185, 129, 0.3);
+      }
+
+      50% {
+        box-shadow: 0 0 14px 4px rgba(16, 185, 129, 0.15);
+      }
+    }
+
+    /* Toggle */
+    .toggle-wrap {
+      display: flex;
+      align-items: center;
+      gap: 7px;
+      flex-shrink: 0;
+    }
+
+    .toggle-label {
+      font-size: 10px;
+      font-weight: 600;
+      color: var(--muted);
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+    }
+
+    .toggle {
+      position: relative;
+      width: 36px;
+      height: 20px;
+      cursor: pointer;
+    }
+
+    .toggle input {
+      opacity: 0;
+      width: 0;
+      height: 0;
+    }
+
+    .toggle-track {
+      position: absolute;
+      inset: 0;
+      background: var(--border);
+      border-radius: 10px;
+      transition: background 0.3s ease;
+    }
+
+    .toggle-thumb {
+      position: absolute;
+      top: 3px;
+      left: 3px;
+      width: 14px;
+      height: 14px;
+      border-radius: 50%;
+      background: var(--muted);
+      transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    }
+
+    .toggle input:checked~.toggle-track {
+      background: var(--accent);
+      box-shadow: 0 0 12px rgba(99, 102, 241, 0.3);
+    }
+
+    .toggle input:checked~.toggle-thumb {
+      transform: translateX(16px);
+      background: #fff;
+      box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3);
+    }
+
+    /* ── Metrics ─────────────────────────────────── */
+    .metrics {
+      display: grid;
+      grid-template-columns: repeat(3, 1fr);
+      gap: 8px;
+      padding: 12px 16px;
+      background: var(--surface);
+      border-bottom: 1px solid var(--border);
+    }
+
+    .metric-card {
+      background: var(--card);
+      border: 1px solid var(--border);
+      border-radius: var(--radius-sm);
+      padding: 12px 10px 10px;
+      text-align: center;
+      transition: all 0.2s ease;
+    }
+
+    .metric-card:hover {
+      border-color: var(--border-glow);
+      background: var(--card-hover);
+    }
+
+    .metric-value {
+      font-size: 26px;
+      font-weight: 800;
+      line-height: 1;
+      letter-spacing: -0.03em;
+      color: var(--text);
+      margin-bottom: 4px;
+      font-variant-numeric: tabular-nums;
+    }
+
+    .metric-value.green {
+      color: var(--green);
+    }
+
+    .metric-value.red {
+      color: var(--red);
+    }
+
+    .metric-label {
+      font-size: 9px;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.12em;
+      color: var(--muted);
+    }
+
+    /* ── State bar ─────────────────────────────────── */
+    .state-bar {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      padding: 8px 16px;
+      background: var(--surface);
+      border-bottom: 1px solid var(--border);
+      font-size: 11px;
+      color: var(--muted);
+      font-weight: 500;
+    }
+
+    .state-label {
+      font-size: 9px;
+      font-weight: 600;
+      letter-spacing: 0.1em;
+      text-transform: uppercase;
+      color: var(--muted);
+    }
+
+    #state-badge {
+      padding: 2px 8px;
+      border-radius: 4px;
+      font-size: 9px;
+      font-weight: 700;
+      text-transform: uppercase;
+      letter-spacing: 0.1em;
+      background: var(--border);
+      color: var(--muted);
+    }
+
+    #state-badge.idle {
+      background: var(--green-bg);
+      color: var(--green);
+    }
+
+    #state-badge.running {
+      background: var(--yellow-bg);
+      color: var(--yellow);
+    }
+
+    #state-badge.off {
+      background: var(--border);
+      color: var(--muted);
+    }
+
+    #token-status {
+      margin-left: auto;
+      font-size: 10px;
+      font-weight: 600;
+      display: flex;
+      align-items: center;
+      gap: 4px;
+    }
+
+    #token-status::before {
+      content: '';
+      width: 6px;
+      height: 6px;
+      border-radius: 50%;
+      display: inline-block;
+    }
+
+    #token-status.ok {
+      color: var(--green);
+    }
+
+    #token-status.ok::before {
+      background: var(--green);
+    }
+
+    #token-status.bad {
+      color: var(--red);
+    }
+
+    #token-status.bad::before {
+      background: var(--red);
+    }
+
+    #token-status.warn {
+      color: var(--yellow);
+    }
+
+    #token-status.warn::before {
+      background: var(--yellow);
+    }
+
+    /* ── Log section ─────────────────────────────── */
+    .log-section {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      min-height: 0;
+    }
+
+    .log-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 10px 16px 8px;
+      font-size: 10px;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.1em;
+      color: var(--muted);
+      background: var(--surface);
+      border-bottom: 1px solid var(--border);
+    }
+
+    #log-count {
+      background: var(--accent-bg);
+      border: 1px solid rgba(99, 102, 241, 0.15);
+      border-radius: 10px;
+      padding: 1px 8px;
+      font-size: 10px;
+      font-weight: 700;
+      color: var(--accent-soft);
+    }
+
+    .log-table-wrap {
+      flex: 1;
+      overflow-y: auto;
+      scrollbar-width: thin;
+      scrollbar-color: var(--border) transparent;
+    }
+
+    .log-table-wrap::-webkit-scrollbar {
+      width: 5px;
+    }
+
+    .log-table-wrap::-webkit-scrollbar-track {
+      background: transparent;
+    }
+
+    .log-table-wrap::-webkit-scrollbar-thumb {
+      background: var(--border);
+      border-radius: 3px;
+    }
+
+    .log-table-wrap::-webkit-scrollbar-thumb:hover {
+      background: var(--border-glow);
+    }
+
+    table {
+      width: 100%;
+      border-collapse: collapse;
+    }
+
+    thead th {
+      position: sticky;
+      top: 0;
+      padding: 7px 12px;
+      text-align: left;
+      font-size: 9px;
+      font-weight: 700;
+      text-transform: uppercase;
+      letter-spacing: 0.1em;
+      color: var(--muted);
+      background: var(--surface);
+      border-bottom: 1px solid var(--border);
+      z-index: 1;
+    }
+
+    thead th:first-child {
+      width: 60px;
+    }
+
+    thead th:last-child {
+      width: 36%;
+    }
+
+    tbody tr {
+      border-bottom: 1px solid rgba(30, 34, 53, 0.6);
+      transition: all 0.15s ease;
+    }
+
+    tbody tr:hover {
+      background: var(--accent-bg);
+    }
+
+    tbody td {
+      padding: 7px 12px;
+      vertical-align: middle;
+      white-space: nowrap;
+    }
+
+    .td-id {
+      font-family: var(--mono);
+      font-size: 10px;
+      color: var(--accent-soft);
+      font-variant-numeric: tabular-nums;
+      cursor: pointer;
+      transition: color 0.15s;
+    }
+
+    .td-id:hover {
+      color: var(--accent);
+      text-decoration: underline;
+    }
+
+    .td-type {
+      font-family: var(--font);
+      font-size: 11px;
+      font-weight: 700;
+      letter-spacing: 0.02em;
+      color: var(--cyan);
+    }
+
+    .td-time {
+      font-family: var(--mono);
+      font-size: 10px;
+      color: var(--text-dim);
+      font-variant-numeric: tabular-nums;
+    }
+
+    /* Status badges */
+    .badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 3px;
+      padding: 2px 8px;
+      border-radius: 4px;
+      font-size: 9px;
+      font-weight: 700;
+      letter-spacing: 0.03em;
+    }
+
+    .badge-ok {
+      background: var(--green-bg);
+      color: var(--green);
+    }
+
+    .badge-fail {
+      background: var(--red-bg);
+      color: var(--red);
+    }
+
+    .badge-proc {
+      background: var(--yellow-bg);
+      color: var(--yellow);
+    }
+
+    .td-error {
+      max-width: 120px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      font-size: 10px;
+      color: var(--red);
+      cursor: default;
+    }
+
+    .td-error.empty {
+      color: var(--muted);
+    }
+
+    .log-empty {
+      padding: 32px 16px;
+      text-align: center;
+      color: var(--muted);
+      font-size: 12px;
+      letter-spacing: 0.02em;
+    }
+
+    .log-empty::before {
+      content: '📋';
+      display: block;
+      font-size: 24px;
+      margin-bottom: 8px;
+      opacity: 0.4;
+    }
+
+    /* ── Detail overlay ─────────────────────────── */
+    .detail-overlay {
+      display: none;
+      position: fixed;
+      inset: 0;
+      background: rgba(0, 0, 0, 0.7);
+      backdrop-filter: blur(4px);
+      z-index: 100;
+    }
+
+    .detail-overlay.open {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      animation: fadeIn 0.2s ease;
+    }
+
+    @keyframes fadeIn {
+      from {
+        opacity: 0;
+      }
+
+      to {
+        opacity: 1;
+      }
+    }
+
+    .detail-panel {
+      width: 92%;
+      max-height: 80vh;
+      background: var(--card);
+      border: 1px solid var(--border-glow);
+      border-radius: var(--radius);
+      overflow: hidden;
+      display: flex;
+      flex-direction: column;
+      box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+    }
+
+    .detail-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 12px 16px;
+      background: var(--surface);
+      border-bottom: 1px solid var(--border);
+      font-size: 12px;
+      font-weight: 700;
+      color: var(--accent-soft);
+    }
+
+    .detail-close {
+      background: none;
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      color: var(--muted);
+      cursor: pointer;
+      font-size: 14px;
+      width: 28px;
+      height: 28px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      transition: all 0.15s;
+    }
+
+    .detail-close:hover {
+      color: var(--text);
+      background: var(--card-hover);
+      border-color: var(--border-glow);
+    }
+
+    .detail-body {
+      padding: 14px 16px;
+      overflow-y: auto;
+      font-size: 11px;
+      line-height: 1.6;
+      max-height: 65vh;
+    }
+
+    .detail-row {
+      display: flex;
+      gap: 10px;
+      padding: 6px 0;
+      border-bottom: 1px solid rgba(30, 34, 53, 0.4);
+    }
+
+    .detail-label {
+      width: 90px;
+      flex-shrink: 0;
+      color: var(--muted);
+      font-weight: 600;
+      text-transform: uppercase;
+      font-size: 9px;
+      letter-spacing: 0.06em;
+    }
+
+    .detail-value {
+      flex: 1;
+      word-break: break-all;
+      color: var(--text);
+      font-family: var(--mono);
+      font-size: 10px;
+    }
+
+    .detail-value.error {
+      color: var(--red);
+    }
+
+    .detail-value.ok {
+      color: var(--green);
+    }
+
+    /* ── Action buttons ─────────────────────────── */
+    .actions {
+      display: flex;
+      gap: 8px;
+      padding: 12px 16px;
+      border-top: 1px solid var(--border);
+      background: var(--surface);
+    }
+
+    .btn {
+      flex: 1;
+      padding: 9px 12px;
+      font-family: var(--font);
+      font-size: 11px;
+      font-weight: 600;
+      letter-spacing: 0.02em;
+      border: 1px solid var(--border);
+      border-radius: var(--radius-sm);
+      background: var(--card);
+      color: var(--text-dim);
+      cursor: pointer;
+      transition: all 0.2s ease;
+    }
+
+    .btn:hover {
+      background: var(--card-hover);
+      border-color: var(--border-glow);
+      color: var(--text);
+      transform: translateY(-1px);
+    }
+
+    .btn:active {
+      transform: translateY(0);
+      opacity: 0.8;
+    }
+
+    .btn-primary {
+      background: linear-gradient(135deg, var(--accent), #7c3aed);
+      border-color: transparent;
+      color: #fff;
+      box-shadow: 0 2px 8px rgba(99, 102, 241, 0.25);
+    }
+
+    .btn-primary:hover {
+      background: linear-gradient(135deg, #818cf8, #8b5cf6);
+      border-color: transparent;
+      color: #fff;
+      box-shadow: 0 4px 14px rgba(99, 102, 241, 0.35);
+    }
+
+    /* ── Signature ──────────────────────────────── */
+    .signature {
+      padding: 10px 16px;
+      text-align: center;
+      font-size: 10px;
+      letter-spacing: 0.04em;
+      color: var(--muted);
+      background: var(--bg);
+      border-top: 1px solid var(--border);
+    }
+
+    .signature a {
+      color: var(--accent-soft);
+      text-decoration: none;
+      font-weight: 500;
+      transition: color 0.15s;
+    }
+
+    .signature a:hover {
+      color: var(--text);
+    }
+
+    /* ── Animations ──────────────────────────────── */
+    @keyframes slideUp {
+      from {
+        opacity: 0;
+        transform: translateY(6px);
+      }
+
+      to {
+        opacity: 1;
+        transform: translateY(0);
+      }
+    }
+
+    .metric-card {
+      animation: slideUp 0.3s ease forwards;
+    }
+
+    .metric-card:nth-child(2) {
+      animation-delay: 0.05s;
+    }
+
+    .metric-card:nth-child(3) {
+      animation-delay: 0.1s;
+    }
+  </style>
+</head>
+
+<body>
+
+  <!-- Header -->
+  <header>
+    <img src="icon48.png" class="logo-img"
+      style="width:28px;height:28px;border-radius:8px;box-shadow:0 2px 8px rgba(99,102,241,0.3)">
+    <div class="header-info">
+      <div class="header-title">Flow Agent</div>
+      <div class="header-sub">AI Video Automation Agent</div>
+    </div>
+    <div id="conn-dot"></div>
+    <div class="toggle-wrap">
+      <span class="toggle-label" id="toggle-label">OFF</span>
+      <label class="toggle">
+        <input type="checkbox" id="main-toggle">
+        <span class="toggle-track"></span>
+        <span class="toggle-thumb"></span>
+      </label>
+    </div>
+  </header>
+
+  <!-- Metrics -->
+  <div class="metrics">
+    <div class="metric-card">
+      <div class="metric-value" id="m-total">0</div>
+      <div class="metric-label">Total</div>
+    </div>
+    <div class="metric-card">
+      <div class="metric-value green" id="m-success">0</div>
+      <div class="metric-label">Success</div>
+    </div>
+    <div class="metric-card">
+      <div class="metric-value red" id="m-failed">0</div>
+      <div class="metric-label">Failed</div>
+    </div>
+  </div>
+
+  <!-- State bar -->
+  <div class="state-bar">
+    <span class="state-label">State</span>
+    <span id="state-badge" class="off">off</span>
+    <span id="token-status" class="bad">no token</span>
+  </div>
+
+  <!-- Request log -->
+  <div class="log-section">
+    <div class="log-header">
+      Request Log
+      <span id="log-count">0</span>
+    </div>
+
+    <div class="log-table-wrap">
+      <table>
+        <thead>
+          <tr>
+            <th>ID</th>
+            <th>Type</th>
+            <th>Time</th>
+            <th>Status</th>
+            <th>Error</th>
+          </tr>
+        </thead>
+        <tbody id="log-body">
+          <tr>
+            <td colspan="5" class="log-empty">No requests yet</td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+  </div>
+
+  <!-- Actions -->
+  <div class="actions">
+    <button class="btn btn-primary" id="btn-flow">Open Flow Tab</button>
+    <button class="btn" id="btn-token">Refresh Token</button>
+  </div>
+
+  <!-- Signature -->
+  <div class="signature">
+    <a href="https://github.com/kodelyx/flow-agent" target="_blank">
+      <svg width="12" height="12" viewBox="0 0 16 16" fill="currentColor" style="vertical-align:-2px;margin-right:3px">
+        <path
+          d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27s1.36.09 2 .27c1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.01 8.01 0 0016 8c0-4.42-3.58-8-8-8z" />
+      </svg>Flow Agent</a> · built by <a href="https://kodelyx.com" target="_blank">kodelyx</a>
+  </div>
+
+  <!-- Detail overlay -->
+  <div class="detail-overlay" id="detail-overlay">
+    <div class="detail-panel">
+      <div class="detail-header">
+        <span id="detail-title">Request Detail</span>
+        <button class="detail-close" id="detail-close">&times;</button>
+      </div>
+      <div class="detail-body" id="detail-body"></div>
+    </div>
+  </div>
+
+  <script src="side_panel.js"></script>
+</body>
+
+</html>

flow-agent/extension/side_panel.js

@@ -0,0 +1,293 @@
+/**
+ * Flow Agent — Side Panel
+ * Displays live connection status, metrics, and request log.
+ */
+
+// ── Type label map ───────────────────────────────────────────
+
+const TYPE_LABELS = {
+  // Worker request types
+  GENERATE_IMAGE:           'GEN IMAGE',
+  REGENERATE_IMAGE:         'REGEN IMAGE',
+  EDIT_IMAGE:               'EDIT IMAGE',
+  GENERATE_CHARACTER_IMAGE: 'GEN REF',
+  REGENERATE_CHARACTER_IMAGE: 'REGEN REF',
+  EDIT_CHARACTER_IMAGE:     'EDIT REF',
+  GENERATE_VIDEO:           'GEN VIDEO',
+  GENERATE_VIDEO_REFS:      'GEN VIDEO FROM REFS',
+  UPSCALE_VIDEO:            'UPSCALE VIDEO',
+  // Captcha action types
+  IMAGE_GENERATION:         'GEN IMAGE',
+  VIDEO_GENERATION:         'GEN VIDEO',
+  // Extension-classified API types
+  GEN_IMG:                  'GEN IMAGE',
+  GEN_VID:                  'GEN VIDEO',
+  GEN_VID_REF:              'GEN VIDEO FROM REFS',
+  UPSCALE:                  'UPSCALE VIDEO',
+  UPS_IMG:                  'UPSCALE IMAGE',
+  POLL:                     'CHECK GEN VIDEO',
+  CREDITS:                  'CHECK CREDIT',
+  CREATE_PROJECT:           'CREATE PROJECT',
+  UPLOAD:                   'UPLOAD IMAGE',
+  MEDIA:                    'READ MEDIA',
+  TRACKING:                 'GOOGLE FLOW TRACK',
+  URL_REFRESH:              'URL REFRESH',
+  TRPC:                     'TRPC',
+  API:                      'API',
+};
+
+function formatType(type) {
+  if (!type) return '—';
+  return TYPE_LABELS[type] || type.slice(0, 5).toUpperCase();
+}
+
+// ── Time formatting ──────────────────────────────────────────
+
+function formatTime(iso) {
+  if (!iso) return '—';
+  try {
+    const d = new Date(iso);
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    return `${hh}:${mm}:${ss}`;
+  } catch {
+    return '—';
+  }
+}
+
+// ── Status update ────────────────────────────────────────────
+
+function updateStatus(data) {
+  if (!data) return;
+
+  // Connection dot
+  const dot = document.getElementById('conn-dot');
+  const connected = data.agentConnected;
+  dot.className = connected ? 'on' : '';
+
+  // Toggle state
+  const toggle = document.getElementById('main-toggle');
+  const toggleLabel = document.getElementById('toggle-label');
+  const isOn = data.state !== 'off';
+  toggle.checked = isOn;
+  toggleLabel.textContent = isOn ? 'ON' : 'OFF';
+
+  // State badge
+  const stateBadge = document.getElementById('state-badge');
+  const st = data.state || 'off';
+  stateBadge.textContent = st;
+  stateBadge.className = st; // idle | running | off
+
+  // Token status
+  const tokenEl = document.getElementById('token-status');
+  if (data.flowKeyPresent) {
+    const ageMs = data.tokenAge || 0;
+    const ageMin = Math.round(ageMs / 60000);
+    if (ageMs > 3600000) {
+      tokenEl.textContent = `token expired — open Flow to refresh`;
+      tokenEl.className = 'warn';
+    } else {
+      tokenEl.textContent = `token synced ${ageMin}m`;
+      tokenEl.className = 'ok';
+    }
+    // Auto-refresh when token age > 55 min and connected
+    if (ageMs > 3300000 && data.agentConnected) {
+      chrome.runtime.sendMessage({ type: 'REFRESH_TOKEN' });
+    }
+  } else {
+    tokenEl.textContent = 'no token';
+    tokenEl.className = 'bad';
+  }
+
+  // Metrics
+  const m = data.metrics || {};
+  document.getElementById('m-total').textContent   = m.requestCount || 0;
+  document.getElementById('m-success').textContent = m.successCount || 0;
+  document.getElementById('m-failed').textContent  = m.failedCount  || 0;
+}
+
+// ── Request log ──────────────────────────────────────────────
+
+function updateRequestLog(entries) {
+  const tbody = document.getElementById('log-body');
+  const countEl = document.getElementById('log-count');
+
+  if (!entries || entries.length === 0) {
+    tbody.innerHTML = '<tr><td colspan="5" class="log-empty">No requests yet</td></tr>';
+    countEl.textContent = '0';
+    return;
+  }
+
+  countEl.textContent = entries.length;
+  _logEntries = entries;
+
+  // Render newest first (entries already sorted DESC by background.js)
+  const rows = entries.map((entry) => {
+    const shortId = entry.id ? String(entry.id).slice(0, 8) : '—';
+    const type   = formatType(entry.type || entry.method);
+    const time   = formatTime(entry.time || entry.timestamp || entry.createdAt);
+    const status = entry.status || entry.state || 'pending';
+    const error  = entry.error || '';
+
+    let badgeHtml;
+    if (status === 'COMPLETED' || status === 'success') {
+      badgeHtml = '<span class="badge badge-ok">&#10003; done</span>';
+    } else if (status === 'FAILED' || status === 'failed' || (typeof status === 'number' && status >= 400)) {
+      badgeHtml = '<span class="badge badge-fail">&#10007; fail</span>';
+    } else if (status === 'PROCESSING') {
+      badgeHtml = '<span class="badge badge-proc">&#9203; gen...</span>';
+    } else if (status === 200 || status === 'processing') {
+      badgeHtml = '<span class="badge badge-proc">&#9203; sent</span>';
+    } else {
+      badgeHtml = '<span class="badge badge-proc">&#9203; sent</span>';
+    }
+
+    const errorDisplay = error
+      ? `<td class="td-error" title="${escHtml(error)}">${escHtml(truncate(error, 28))}</td>`
+      : `<td class="td-error empty">—</td>`;
+
+    return `<tr>
+      <td class="td-id" data-request-id="${escHtml(entry.id || '')}">${escHtml(shortId)}</td>
+      <td class="td-type">${escHtml(type)}</td>
+      <td class="td-time">${escHtml(time)}</td>
+      <td>${badgeHtml}</td>
+      ${errorDisplay}
+    </tr>`;
+  });
+
+  tbody.innerHTML = rows.join('');
+
+  // Attach click handlers to ID cells
+  tbody.querySelectorAll('.td-id[data-request-id]').forEach(td => {
+    td.addEventListener('click', () => {
+      const reqId = td.getAttribute('data-request-id');
+      if (reqId) showRequestDetail(reqId);
+    });
+  });
+}
+
+function escHtml(str) {
+  return String(str)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function truncate(str, len) {
+  if (!str || str.length <= len) return str;
+  return str.slice(0, len) + '…';
+}
+
+// ── Request detail modal ────────────────────────────────────
+
+let _logEntries = [];
+
+function showRequestDetail(reqId) {
+  const entry = _logEntries.find(e => e.id === reqId);
+  if (!entry) return;
+
+  const overlay = document.getElementById('detail-overlay');
+  const title = document.getElementById('detail-title');
+  const body = document.getElementById('detail-body');
+
+  title.textContent = `Request ${String(reqId).slice(0, 12)}`;
+
+  const fields = [
+    ['ID', entry.id],
+    ['Type', formatType(entry.type || entry.method)],
+    ['Time', formatTime(entry.time || entry.timestamp || entry.createdAt)],
+    ['Status', entry.status || entry.state || 'pending'],
+    ['HTTP', entry.httpStatus || '—'],
+    ['URL', entry.url || '—'],
+    ['Payload', entry.payloadSummary || '—'],
+    ['Response', entry.responseSummary || '—'],
+    ['Error', entry.error || '—'],
+  ];
+
+  body.innerHTML = fields.map(([label, value]) => {
+    let cls = 'detail-value';
+    if (label === 'Error' && value && value !== '—') cls += ' error';
+    if (label === 'Status' && (value === 'COMPLETED' || value === 'success')) cls += ' ok';
+    return `<div class="detail-row">
+      <div class="detail-label">${escHtml(label)}</div>
+      <div class="${cls}">${escHtml(String(value || '—'))}</div>
+    </div>`;
+  }).join('');
+
+  overlay.classList.add('open');
+}
+
+document.getElementById('detail-close').addEventListener('click', () => {
+  document.getElementById('detail-overlay').classList.remove('open');
+});
+
+document.getElementById('detail-overlay').addEventListener('click', (e) => {
+  if (e.target === e.currentTarget) {
+    e.currentTarget.classList.remove('open');
+  }
+});
+
+// ── Initial data fetch ───────────────────────────────────────
+
+function fetchStatus() {
+  chrome.runtime.sendMessage({ type: 'STATUS' }, (data) => {
+    if (chrome.runtime.lastError) return;
+    updateStatus(data);
+  });
+}
+
+function fetchLog() {
+  chrome.runtime.sendMessage({ type: 'REQUEST_LOG' }, (data) => {
+    if (chrome.runtime.lastError) return;
+    if (data && data.log) updateRequestLog(data.log);
+  });
+}
+
+// ── Message listener (push updates) ─────────────────────────
+
+chrome.runtime.onMessage.addListener((msg) => {
+  if (msg.type === 'STATUS_PUSH') {
+    fetchStatus();
+  }
+  if (msg.type === 'REQUEST_LOG_UPDATE') {
+    if (msg.log) updateRequestLog(msg.log);
+  }
+});
+
+// ── Toggle (connect / disconnect) ───────────────────────────
+
+document.getElementById('main-toggle').addEventListener('change', (e) => {
+  const msgType = e.target.checked ? 'RECONNECT' : 'DISCONNECT';
+  chrome.runtime.sendMessage({ type: msgType }, () => {
+    if (chrome.runtime.lastError) return;
+    setTimeout(fetchStatus, 400);
+  });
+});
+
+// ── Action buttons ───────────────────────────────────────────
+
+document.getElementById('btn-flow').addEventListener('click', () => {
+  chrome.runtime.sendMessage({ type: 'OPEN_FLOW_TAB' }, () => {
+    if (chrome.runtime.lastError) return;
+  });
+});
+
+document.getElementById('btn-token').addEventListener('click', () => {
+  const btn = document.getElementById('btn-token');
+  btn.textContent = 'Opening...';
+  btn.disabled = true;
+  chrome.runtime.sendMessage({ type: 'REFRESH_TOKEN' }, () => {
+    if (chrome.runtime.lastError) { /* ignore */ }
+    btn.textContent = 'Refresh Token';
+    btn.disabled = false;
+  });
+});
+
+// ── Init ─────────────────────────────────────────────────────
+
+document.addEventListener('DOMContentLoaded', () => {
+  fetchStatus();
+  fetchLog();
+});

flow-agent/media-id.js

@@ -0,0 +1,12 @@
+cat_beach.png : cc312ed8-e13f-4b89-a25d-4d45786daf15
+dragon_end.png : 9f7ee671-62cf-4380-8896-38a1cc0ce943
+dragon_start.png : 76690529-192b-42ee-b6d5-ebc003ec7467
+end_frame.png : dfa0816c-dfc5-41bd-bbbf-0ef865a377de
+start_frame.png : 41f43cdb-293f-4e41-8bb2-664fd269619b
+upload_08eb0364414643f9bede2b4e139375d9_test_t2i.png : a821e119-ebdb-419d-8991-f80ecfa63637
+upload_125349fc756b4e6f8ead3b2a9d6aa036_test_i2v.mp4 : 84e699af-72ba-45db-9a0e-ea60cda3420b
+upload_55a0bcc69fa74bf4a85790a23ba0e92a_test_t2i.png : e6dcaab9-266f-4dd1-bf04-63bf8cd5a27b
+upload_6fb7eab112a04007b7468ce3b4a7c5d9_test_t2i.png : 0e61aa50-fc25-4c58-95ff-ea2587e66265
+upload_c0e77a6605844f5d93182e9fc6aaaa5e_test_i2v.mp4 : 9f598bab-5f73-403d-b679-7cd223f42523
+upload_cd9aed3690464e06953eb74c5b254619_test_t2i.png : a2ef1c23-c2bb-42a9-8cd2-03264a754623
+upload_ce5bb751ddeb461c9392c617af058186_test_i2v.mp4 : 8eb1f60d-0f6a-44b3-835d-8f268c565818