448 lines
20 KiB
JavaScript
448 lines
20 KiB
JavaScript
// Flow Auto-Pilot v2 — drives the Google Flow AGENT panel and HARVESTS outputs.
|
||
//
|
||
// Reuses DEALGOD's "poll until the SPA settles" discipline (waitForStable), NOT its
|
||
// full selector-discovery engine — Flow is one known page, not the open web, so
|
||
// auto-recipe/variance scoring would be over-engineering here.
|
||
//
|
||
// Loop: poll local queue -> type prompt into the agent box -> submit ->
|
||
// wait for a NEW asset to appear + the media grid to stop growing ->
|
||
// harvest the new video/image URL(s) -> report them back to the queue.
|
||
//
|
||
// Prereq you set ONCE by hand in Flow: Agent settings -> Confirm before generating
|
||
// = "Never", model + x4 defaults. The driver still clicks a confirm button if one
|
||
// shows up (covers both modes), but "Never" is what makes it truly unattended.
|
||
|
||
let settings = {
|
||
serverUrl: 'http://localhost:8017',
|
||
isRunning: false,
|
||
autoStart: false, // begin polling the moment the Flow tab loads (for scripted launch)
|
||
// Optional CSS overrides — leave blank to use the resilient generic finders.
|
||
promptSel: '',
|
||
submitSel: '',
|
||
resultSel: '', // scope for harvesting (e.g. the media library container)
|
||
pollInterval: 4000,
|
||
genTimeoutMs: 8 * 60 * 1000, // Veo clips can take minutes
|
||
// Pacing — stay under Google's per-account rate/abuse flag ("unusual activity").
|
||
taskDelayMs: 20000, // base pause between tasks (jittered up to 2x)
|
||
restEvery: 15, // after this many gens, take a longer rest
|
||
restMs: 15 * 60 * 1000, // length of that scheduled rest
|
||
autoRefreshOnJam: true, // refresh WHEN RESUMING after the abuse flag (never during the freeze)
|
||
cooldownUntil: 0, // epoch ms; set on rate-limit/rest, persists across reload
|
||
reloadOnResume: false // set by the abuse flag: hard-refresh once the freeze ends, then resume
|
||
};
|
||
|
||
let pollTimeout = null;
|
||
let generationInProgress = false;
|
||
let successCount = 0;
|
||
let consecutiveRateLimits = 0;
|
||
|
||
function init() {
|
||
chrome.storage.local.get(settings, (data) => {
|
||
settings = { ...settings, ...data };
|
||
if (settings.autoStart && !settings.isRunning) {
|
||
settings.isRunning = true;
|
||
chrome.storage.local.set({ isRunning: true }); // so the popup reflects it
|
||
}
|
||
log('system', `Content script connected (${settings.isRunning ? 'ACTIVE' : 'idle'}).`);
|
||
if (settings.isRunning) startPolling();
|
||
});
|
||
}
|
||
|
||
// ---- helpers -------------------------------------------------------------
|
||
|
||
const sleep = (ms) => new Promise(r => setTimeout(r, ms));
|
||
const visible = (el) => !!el && el.offsetWidth > 0 && el.offsetHeight > 0;
|
||
|
||
// Poll a predicate until truthy or timeout. Returns the truthy value or null.
|
||
async function waitFor(pred, maxMs = 15000, step = 400) {
|
||
const t0 = Date.now();
|
||
while (Date.now() - t0 < maxMs) {
|
||
let v; try { v = pred(); } catch (_) { v = null; }
|
||
if (v) return v;
|
||
await sleep(step);
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// DEALGOD discipline: call countFn() every `step`ms; resolve once the value is
|
||
// the SAME for `stableFor` consecutive polls (the grid stopped growing), or cap.
|
||
async function waitForStable(countFn, { maxMs = settings.genTimeoutMs, step = 1500, stableFor = 2, min = 1 } = {}) {
|
||
const t0 = Date.now();
|
||
let prev = -1, stable = 0;
|
||
while (Date.now() - t0 < maxMs) {
|
||
const c = countFn();
|
||
if (c >= min && c === prev) {
|
||
if (++stable >= stableFor) return c;
|
||
} else {
|
||
stable = 0;
|
||
}
|
||
prev = c;
|
||
await sleep(step);
|
||
}
|
||
return prev;
|
||
}
|
||
|
||
// React-aware value injection (kept from v1 — this part was correct).
|
||
function setElementValue(el, value) {
|
||
if (!el) return false;
|
||
el.focus();
|
||
if (el.tagName === 'TEXTAREA' || el.tagName === 'INPUT') {
|
||
const setter = Object.getOwnPropertyDescriptor(el.__proto__, 'value')?.set;
|
||
setter ? setter.call(el, value) : (el.value = value); // bypass React's value shadowing
|
||
el.dispatchEvent(new Event('input', { bubbles: true }));
|
||
el.dispatchEvent(new Event('change', { bubbles: true }));
|
||
} else {
|
||
el.innerText = value;
|
||
el.dispatchEvent(new InputEvent('input', { bubbles: true, cancelable: true, inputType: 'insertText', data: value }));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// Read whatever text is currently in the editor (textarea value or contenteditable text).
|
||
function editorText(el) {
|
||
const t = (el.tagName === 'TEXTAREA' || el.tagName === 'INPUT') ? el.value : (el.innerText || el.textContent || '');
|
||
return (t || '').trim();
|
||
}
|
||
|
||
// Ask the background worker for a TRUSTED action via the DevTools Protocol.
|
||
// Flow's editor ignores synthetic DOM events (isTrusted=false): the text shows but
|
||
// the app's state stays empty ("no prompt" on send). CDP Input.* events are trusted.
|
||
function bg(msg) {
|
||
return new Promise((resolve) => {
|
||
try { chrome.runtime.sendMessage(msg, (r) => resolve(chrome.runtime.lastError ? null : r)); }
|
||
catch (_) { resolve(null); }
|
||
});
|
||
}
|
||
|
||
// Focus, clear, then insert the prompt as trusted input. Falls back to DOM injection
|
||
// if the debugger path is unavailable. Returns chars that landed (0 = failed).
|
||
async function typeIntoEditor(el, text) {
|
||
el.focus();
|
||
await sleep(120);
|
||
try { document.execCommand('selectAll', false, null); document.execCommand('delete', false, null); } catch (_) {}
|
||
const r = await bg({ type: 'insertText', text });
|
||
if (!r || !r.ok) {
|
||
try { document.execCommand('insertText', false, text); } catch (_) {} // fallback
|
||
if (!editorText(el).length) setElementValue(el, text);
|
||
}
|
||
await sleep(200);
|
||
return editorText(el).length;
|
||
}
|
||
|
||
// Submit via a trusted Enter (what works by hand). Falls back to synthetic keys.
|
||
async function submitEditor(el) {
|
||
el.focus();
|
||
const r = await bg({ type: 'pressEnter' });
|
||
if (!r || !r.ok) {
|
||
const o = { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true };
|
||
el.dispatchEvent(new KeyboardEvent('keydown', o));
|
||
el.dispatchEvent(new KeyboardEvent('keypress', o));
|
||
el.dispatchEvent(new KeyboardEvent('keyup', o));
|
||
}
|
||
}
|
||
|
||
// ---- element finders (few, known targets; overrides win) -----------------
|
||
|
||
function findAgentInput() {
|
||
if (settings.promptSel) { const el = document.querySelector(settings.promptSel); if (visible(el)) return el; }
|
||
// Flow's agent box is a visible contenteditable[role=textbox] or textarea.
|
||
const boxes = [
|
||
...document.querySelectorAll('div[contenteditable="true"][role="textbox"]'),
|
||
...document.querySelectorAll('div[contenteditable="true"]'),
|
||
...document.querySelectorAll('textarea')
|
||
];
|
||
return boxes.find(visible) || null;
|
||
}
|
||
|
||
// John's by-hand ritual, step 1: after a (re)load, don't type the instant the box
|
||
// exists — wait for the agent sidebar to finish hydrating, then re-find it.
|
||
async function waitForAgentReady(maxMs = 30000) {
|
||
const el = await waitFor(findAgentInput, maxMs);
|
||
if (!el) return null;
|
||
await sleep(1500);
|
||
const el2 = findAgentInput();
|
||
return visible(el2) ? el2 : null;
|
||
}
|
||
|
||
// The square STOP control that replaces send while a generation is queued —
|
||
// the "it stuck" signal you watch for by hand.
|
||
function findStopSquare() {
|
||
return [...document.querySelectorAll('button, [role="button"]')].find(b => visible(b) && !b.disabled &&
|
||
/\b(stop|cancel)\b/i.test((b.getAttribute('aria-label') || '') + ' ' + (b.getAttribute('title') || '')));
|
||
}
|
||
|
||
// The submit control is the unlabeled arrow near the input. Find the nearest
|
||
// enabled button after the input, preferring aria-labels that read like "send".
|
||
function findSubmit(inputEl) {
|
||
if (settings.submitSel) { const el = document.querySelector(settings.submitSel); if (visible(el) && !el.disabled) return el; }
|
||
const scope = inputEl?.closest('form, [class*="composer"], [class*="session"], [class*="input"]') || document;
|
||
const btns = [...scope.querySelectorAll('button, [role="button"]')].filter(b => visible(b) && !b.disabled);
|
||
// ONLY a control explicitly labelled send/submit. No "last icon button" guess — that's what
|
||
// was clicking the + / menu and opening popups. If unsure, return null (trusted Enter handles it).
|
||
return btns.find(b => /\b(send|submit)\b/i.test((b.getAttribute('aria-label') || '') + ' ' + (b.getAttribute('title') || ''))) || null;
|
||
}
|
||
|
||
// Snapshot real media URLs currently on the page (the harvest surface).
|
||
function snapshotAssets() {
|
||
const scope = (settings.resultSel && document.querySelector(settings.resultSel)) || document;
|
||
const urls = new Set();
|
||
const ok = (u) => u && !/^data:/.test(u) && (/^https?:/.test(u) || /^blob:/.test(u));
|
||
const push = (u) => { if (ok(u)) urls.add(u.split('#')[0]); };
|
||
scope.querySelectorAll('video[src]').forEach(v => push(v.src));
|
||
scope.querySelectorAll('video source[src]').forEach(s => push(s.src));
|
||
scope.querySelectorAll('video[poster]').forEach(v => push(v.poster));
|
||
scope.querySelectorAll('a[href]').forEach(a => {
|
||
if (a.hasAttribute('download') || /googleusercontent|media\.getMediaUrl|\/media\//i.test(a.href)) push(a.href);
|
||
});
|
||
// images: match media hosts + the redirect API + blobs (diffed before/after, so only NEW ones count)
|
||
scope.querySelectorAll('img[src]').forEach(i => {
|
||
if (/googleusercontent|lh3|ggpht|storage|media\.getMediaUrl|^blob:/i.test(i.src)) push(i.src);
|
||
});
|
||
return urls;
|
||
}
|
||
|
||
// Detect Flow's own failure banner so we can skip fast instead of waiting the full timeout.
|
||
function flowError() {
|
||
return [...document.querySelectorAll('*')].some(e => visible(e) &&
|
||
/something went wrong|please try again|couldn'?t generate|failed to generate|generation failed/i.test(e.textContent || '') &&
|
||
(e.textContent || '').length < 90);
|
||
}
|
||
|
||
// The account-level abuse/rate flag ("unusual activity" / "Help Center"). Persistent —
|
||
// retrying makes it worse — so this triggers a long back-off, not a "Try again".
|
||
function persistentError() {
|
||
return [...document.querySelectorAll('*')].some(e => visible(e) &&
|
||
/unusual activity|help center|temporarily (blocked|unavailable)|too many requests|try again later/i.test(e.textContent || '') &&
|
||
(e.textContent || '').length < 180);
|
||
}
|
||
|
||
// Flow's "Try again" button, shown beside the "Something went wrong" banner.
|
||
// Clicking it re-runs the SAME prompt (no re-injection needed) — the manual fix.
|
||
function findTryAgain() {
|
||
return [...document.querySelectorAll('button, [role="button"]')]
|
||
.find(b => visible(b) && !b.disabled && /^\s*try again\s*$/i.test(b.innerText || ''));
|
||
}
|
||
|
||
// Poll for: a new asset (win), or Flow's transient "Something went wrong". Flow
|
||
// errors constantly under load, so instead of failing we AUTO-CLICK "Try again"
|
||
// (what works by hand) up to maxRetries, with a cooldown so a lingering banner
|
||
// doesn't burn all the retries at once. Returns 'asset' | 'error' | null(timeout).
|
||
async function waitForResultOrError(baseCount, maxMs, maxRetries = 3) {
|
||
const t0 = Date.now();
|
||
let retries = 0, cooldownUntil = 0;
|
||
while (Date.now() - t0 < maxMs) {
|
||
if (snapshotAssets().size > baseCount) return 'asset';
|
||
if (Date.now() - t0 > 6000 && persistentError()) return 'ratelimit'; // abuse flag: back off, don't retry
|
||
const now = Date.now();
|
||
if (now > cooldownUntil) {
|
||
const btn = findTryAgain();
|
||
if (btn) {
|
||
if (retries >= maxRetries) return 'error'; // gave it maxRetries shots
|
||
retries++;
|
||
log('info', `Flow hiccup — clicking "Try again" (${retries}/${maxRetries}).`);
|
||
btn.click();
|
||
cooldownUntil = now + 15000; // let it re-generate before re-checking
|
||
await sleep(4000);
|
||
continue;
|
||
}
|
||
if (now - t0 > 8000 && flowError()) return 'error'; // errored, no retry offered
|
||
}
|
||
await sleep(2500);
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// ---- queue loop ----------------------------------------------------------
|
||
|
||
// Entry point (Start / reload). Kicks the first poll soon; the rest is paced.
|
||
function startPolling() {
|
||
if (pollTimeout) clearTimeout(pollTimeout);
|
||
if (settings.isRunning) scheduleNext(true);
|
||
}
|
||
|
||
// Schedule the next poll. Honours a persisted cooldown (rate-limit back-off or scheduled
|
||
// rest); otherwise waits a jittered human-ish gap so we don't machine-gun the account.
|
||
function scheduleNext(immediate = false) {
|
||
if (pollTimeout) clearTimeout(pollTimeout);
|
||
if (!settings.isRunning) return;
|
||
const now = Date.now();
|
||
let delay;
|
||
if (settings.cooldownUntil && now < settings.cooldownUntil) {
|
||
delay = settings.cooldownUntil - now;
|
||
log('system', `Cooling down ~${Math.max(1, Math.round(delay / 60000))} min before next…`);
|
||
} else if (immediate) {
|
||
delay = 2000;
|
||
} else {
|
||
const base = settings.taskDelayMs || 15000;
|
||
delay = base + Math.floor(Math.random() * base); // base .. 2*base, jittered
|
||
}
|
||
pollTimeout = setTimeout(pollOnce, delay);
|
||
}
|
||
|
||
async function pollOnce() {
|
||
if (!settings.isRunning) return;
|
||
if (generationInProgress) return scheduleNext();
|
||
if (settings.reloadOnResume) {
|
||
// Freeze is over — come back on a FRESH session before touching anything.
|
||
settings.reloadOnResume = false;
|
||
chrome.storage.local.set({ reloadOnResume: false });
|
||
log('system', 'Abuse-flag freeze over — hard refreshing before resuming.');
|
||
const r = await bg({ type: 'hardReload' });
|
||
if (!r || !r.ok) location.reload();
|
||
return;
|
||
}
|
||
try {
|
||
const res = await fetch(`${settings.serverUrl}/next-task`);
|
||
if (res.status === 204) return scheduleNext(); // queue drained
|
||
if (!res.ok) throw new Error(`HTTP ${res.status}`);
|
||
const task = await res.json();
|
||
if (task && task.id) { log('info', `Task ${task.id}: ${String(task.prompt).slice(0, 60)}…`); await executeTask(task); }
|
||
else scheduleNext();
|
||
} catch (err) {
|
||
log('error', `Poll failed: ${err.message}`);
|
||
scheduleNext();
|
||
}
|
||
}
|
||
|
||
// John's by-hand recovery: the thing that actually clears a wedged Flow session is a
|
||
// HARD refresh (cache bypass), not "Try again". Keep the task PENDING server-side,
|
||
// count attempts in storage (survives the reload), and reload the tab.
|
||
async function requeueWithReload(task, why) {
|
||
if (persistentError()) return handleRateLimit(task); // abuse flag outranks any retry — freeze, don't reload
|
||
const key = 'requeue_' + task.id;
|
||
const n = ((await new Promise(r => chrome.storage.local.get({ [key]: 0 }, r)))[key] || 0) + 1;
|
||
if (n > 3) {
|
||
chrome.storage.local.remove(key);
|
||
log('error', `Task ${task.id}: ${why} — 3 hard-refresh retries burned, marking failed.`);
|
||
await reportCompletion(task.id, 'failed', `${why} (after 3 hard refreshes)`, []);
|
||
return;
|
||
}
|
||
chrome.storage.local.set({ [key]: n });
|
||
await reportCompletion(task.id, 'requeue', why, []); // server keeps it PENDING
|
||
log('system', `Task ${task.id}: ${why} — hard refresh ${n}/3, retrying after reload.`);
|
||
setCooldown(20000, 'Hard-refresh retry');
|
||
await sleep(800);
|
||
const r = await bg({ type: 'hardReload' });
|
||
if (!r || !r.ok) location.reload();
|
||
}
|
||
|
||
async function executeTask(task) {
|
||
generationInProgress = true;
|
||
chrome.storage.local.set({ status: 'working' });
|
||
try {
|
||
const input = await waitForAgentReady(30000);
|
||
if (!input) return await requeueWithReload(task, 'agent input never became ready');
|
||
|
||
const before = snapshotAssets();
|
||
|
||
const landed = await typeIntoEditor(input, task.prompt);
|
||
if (!landed) return await requeueWithReload(task, 'prompt did not register in the editor');
|
||
log('info', `Prompt set (${landed} chars). Submitting…`);
|
||
await sleep(600); // John's ritual: paste, wait a sec, THEN enter
|
||
|
||
await submitEditor(input); // trusted Enter via the DevTools Protocol — this submits
|
||
// Success signal = the square stop button appears (or the box empties). If neither,
|
||
// try the labelled submit button once, then hard-refresh — Enter into a wedged
|
||
// session never recovers on its own.
|
||
let took = await waitFor(() => findStopSquare() || editorText(input).length === 0, 6000, 300);
|
||
if (!took) {
|
||
const submit = findSubmit(input);
|
||
if (submit) { submit.click(); log('info', 'Enter fallback → clicked submit.'); }
|
||
took = await waitFor(() => findStopSquare() || editorText(input).length === 0, 6000, 300);
|
||
}
|
||
if (!took) return await requeueWithReload(task, 'submission never stuck (no stop button, prompt still in box)');
|
||
|
||
log('info', 'Submitted (stop square seen). Waiting for generation…');
|
||
|
||
// Wait for a new asset, a Flow error (fast-fail), or timeout. Images should be quick.
|
||
const timeoutMs = task.kind === 'image' ? 3 * 60 * 1000 : settings.genTimeoutMs;
|
||
const outcome = await waitForResultOrError(before.size, timeoutMs);
|
||
if (outcome === 'ratelimit') { await handleRateLimit(task); return; } // long back-off, don't hammer
|
||
if (outcome === 'error') return await requeueWithReload(task, '"Something went wrong" persisted through Try-again');
|
||
if (outcome !== 'asset') {
|
||
const wall = [...document.querySelectorAll('*')].some(e => visible(e) &&
|
||
/out of credits|no credits|insufficient|quota exceeded|run out of|daily limit|reached your limit/i.test(e.textContent || '') &&
|
||
(e.textContent || '').length < 160);
|
||
throw new Error(wall ? 'Real credit/quota wall detected.' : 'Timed out — no new asset (harvest miss or Flow queue).');
|
||
}
|
||
await waitForStable(() => snapshotAssets().size, { min: before.size + 1 });
|
||
|
||
const after = snapshotAssets();
|
||
const fresh = [...after].filter(u => !before.has(u));
|
||
log('success', `Harvested ${fresh.length} asset(s).`);
|
||
|
||
// Browser download — uses your session, no CSP/CORS. Lands in Downloads/flowrinse/<category>/.
|
||
const ext = task.kind === 'video' ? 'mp4' : 'png';
|
||
const cat = (task.category || 'misc').replace(/[^a-z0-9_\-]/gi, '_');
|
||
let saved = 0;
|
||
for (let i = 0; i < fresh.length; i++) {
|
||
const r = await bg({ type: 'download', url: fresh[i], filename: `flowrinse/${cat}/${task.id}_${i}.${ext}` });
|
||
if (r && r.ok) saved++;
|
||
}
|
||
if (fresh.length) log(saved === fresh.length ? 'success' : 'info', `Downloaded ${saved}/${fresh.length} → Downloads/flowrinse/${cat}/`);
|
||
await reportCompletion(task.id, 'success', null, fresh);
|
||
chrome.storage.local.remove('requeue_' + task.id);
|
||
successCount++; consecutiveRateLimits = 0;
|
||
if (settings.restEvery && successCount % settings.restEvery === 0) {
|
||
setCooldown(settings.restMs || 15 * 60 * 1000, `Scheduled rest after ${successCount} gens`);
|
||
}
|
||
} catch (err) {
|
||
log('error', `Task ${task.id} failed: ${err.message}`);
|
||
await reportCompletion(task.id, 'failed', err.message, []);
|
||
} finally {
|
||
generationInProgress = false;
|
||
chrome.storage.local.set({ status: settings.isRunning ? 'running' : 'idle' });
|
||
scheduleNext();
|
||
}
|
||
}
|
||
|
||
async function reportCompletion(id, status, error, assets) {
|
||
try {
|
||
await fetch(`${settings.serverUrl}/task-completed`, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ id, status, error, assets }) // assets = harvested URLs
|
||
});
|
||
} catch (err) {
|
||
log('error', `Report failed: ${err.message}`);
|
||
}
|
||
}
|
||
|
||
// Persisted cooldown (survives a tab reload) — used for rate-limit back-off and rests.
|
||
function setCooldown(ms, why) {
|
||
settings.cooldownUntil = Date.now() + ms;
|
||
chrome.storage.local.set({ cooldownUntil: settings.cooldownUntil });
|
||
log('system', `${why} — pausing ${Math.round(ms / 60000)} min.`);
|
||
}
|
||
|
||
// Hit the account abuse flag ("unusual activity"). This is an ACTIVE account-level
|
||
// flag — worse than "Try again". Any activity while it's up (including reloads)
|
||
// feeds it, and it wears off on its own. So: report the task back as pending,
|
||
// then CEASE COMPLETELY for a solid 30 min (60/90 on repeat hits). The tab is
|
||
// hard-refreshed only when the freeze expires, right before resuming.
|
||
async function handleRateLimit(task) {
|
||
consecutiveRateLimits++;
|
||
const mins = Math.min(90, 30 * consecutiveRateLimits); // 30 → 60 → 90
|
||
await reportCompletion(task.id, 'ratelimited', 'unusual activity — ceasing all activity', []);
|
||
if (settings.autoRefreshOnJam) {
|
||
settings.reloadOnResume = true;
|
||
chrome.storage.local.set({ reloadOnResume: true });
|
||
}
|
||
setCooldown(mins * 60 * 1000, `⚠ Abuse flag ("unusual activity") ×${consecutiveRateLimits} — total freeze`);
|
||
}
|
||
|
||
function log(level, text) {
|
||
console.log(`[Flow][${level}] ${text}`);
|
||
chrome.storage.local.get({ logs: [] }, (r) => {
|
||
chrome.storage.local.set({ logs: [...r.logs, { level, text, timestamp: Date.now() }].slice(-100) });
|
||
});
|
||
}
|
||
|
||
chrome.storage.onChanged.addListener((c, area) => {
|
||
if (area !== 'local') return;
|
||
for (const k of Object.keys(c)) if (k in settings) settings[k] = c[k].newValue;
|
||
if (c.isRunning) { c.isRunning.newValue ? startPolling() : (pollTimeout && clearTimeout(pollTimeout)); }
|
||
});
|
||
|
||
init();
|