takomi 2.1.39 → 2.1.41

package/plugins/takomi-flow/scripts/lib/flow-outcome.mjs

@@ -1,90 +1,115 @@
-import { hasText, openGeneratedMedia } from './flow-ui.mjs';
-
-export async function handleGenerationFollowups(page, request) {
-  if (await hasText(page, /which of these durations would you prefer/i)) {
-    await chooseDuration(page, request.durationSeconds || 4);
-    await page.waitForTimeout(2000);
-  }
-  if (await hasText(page, /costing\s+\d+\s+credits/i)) {
-    return clickApprove(page);
-  }
-  return false;
-}
-
-export async function waitForGenerationOutcome(page, request, options = {}) {
-  const timeoutMs = Number(options.timeoutMs || process.env.TAKOMI_FLOW_WAIT_MS || 300000);
-  const intervalMs = Number(options.intervalMs || process.env.TAKOMI_FLOW_POLL_MS || 5000);
-  const started = Date.now();
-  let approved = false;
-  while (Date.now() - started < timeoutMs) {
-    if (await hasText(page, /which of these durations would you prefer/i)) {
-      await chooseDuration(page, request.durationSeconds || 4);
-    }
-    if (await hasText(page, /costing\s+\d+\s+credits/i)) {
-      approved = await clickApprove(page) || approved;
-    }
-    if (await page.locator('button').filter({ hasText: /download\s*Download/i }).count().catch(() => 0)) {
-      return { status: 'download_ready', approved };
-    }
-    if (await page.locator('img[src*="media.getMediaUrlRedirect"], video').count().catch(() => 0)) {
-      await openGeneratedMedia(page);
-      return { status: 'media_ready', approved };
-    }
-    if (await hasVisibleText(page, /\b\d{1,3}%\b|generating|waiting in the queue|been scheduled/i)) {
-      await page.waitForTimeout(intervalMs);
-      continue;
-    }
-    if (await hasVisibleText(page, /failed|oops, something went wrong/i)) {
-      return { status: 'failed', approved };
-    }
-    await page.waitForTimeout(intervalMs);
-  }
-  return { status: 'timeout', approved };
-}
-
-async function hasVisibleText(page, pattern) {
-  return page.locator('body').evaluate((body, source) => {
-    const regex = new RegExp(source, 'i');
-    const isVisible = element => {
-      const style = window.getComputedStyle(element);
-      const rect = element.getBoundingClientRect();
-      return style.visibility !== 'hidden' && style.display !== 'none' && rect.width > 0 && rect.height > 0;
-    };
-    const walker = document.createTreeWalker(body, NodeFilter.SHOW_ELEMENT);
-    let node = walker.nextNode();
-    while (node) {
-      const visibleChildCount = [...node.children].filter(isVisible).length;
-      if (visibleChildCount === 0 && isVisible(node) && regex.test(node.innerText || node.textContent || '')) {
-        return true;
-      }
-      node = walker.nextNode();
-    }
-    return false;
-  }, pattern.source).catch(() => false);
-}
-
-async function chooseDuration(page, requested) {
-  const options = [4, 6, 8, 10];
-  const closest = options.reduce((best, item) => (
-    Math.abs(item - requested) < Math.abs(best - requested) ? item : best
-  ), options[0]);
-  const option = page.getByText(new RegExp(`^${closest} seconds$`, 'i')).first();
-  if (await option.count().catch(() => 0)) await option.click({ timeout: 10000 }).catch(() => {});
-}
-
-async function clickApprove(page) {
-  const candidates = [
-    page.getByText('Approve', { exact: true }).first(),
-    page.locator('div,button,[role="button"]').filter({ hasText: /^\s*check\s*Approve\s*$/i }).first(),
-    page.locator('text=Approve').first(),
-  ];
-  for (const locator of candidates) {
-    if (!(await locator.count().catch(() => 0))) continue;
-    try {
-      await locator.click({ timeout: 10000, force: true });
-      await page.waitForTimeout(1000);
-      return true;
-    } catch {}
-  }
-  return false;
-}
+import { downloadButton, hasText, openGeneratedMedia } from './flow-ui.mjs';
+import { newMediaIds } from './flow-media.mjs';
+
+export async function handleGenerationFollowups(page, request) {
+  if (await hasText(page, /which of these durations would you prefer/i)) {
+    await chooseDuration(page, request.durationSeconds || 4);
+    await page.waitForTimeout(2000);
+  }
+  if (await hasText(page, /costing\s+\d+\s+credits/i)) {
+    return clickApprove(page);
+  }
+  return false;
+}
+
+export async function waitForGenerationOutcome(page, request, options = {}) {
+  const timeoutMs = Number(options.timeoutMs || process.env.TAKOMI_FLOW_WAIT_MS || 300000);
+  const intervalMs = Number(options.intervalMs || process.env.TAKOMI_FLOW_POLL_MS || 5000);
+  const readyProbeMs = Number(options.readyProbeMs || process.env.TAKOMI_FLOW_READY_PROBE_MS || 45000);
+  const started = Date.now();
+  let lastReadyProbeAt = 0;
+  let approved = false;
+  while (Date.now() - started < timeoutMs) {
+    if (await hasText(page, /which of these durations would you prefer/i)) {
+      await chooseDuration(page, request.durationSeconds || 4);
+    }
+    if (await hasText(page, /costing\s+\d+\s+credits/i)) {
+      approved = await clickApprove(page) || approved;
+    }
+    const freshMediaIds = await newMediaIds(page, options.baselineMediaIds || []);
+    const downloadReady = await downloadButton(page).count().catch(() => 0);
+    if (downloadReady && (!options.baselineMediaIds || freshMediaIds.length || /\/edit\//.test(page.url()))) {
+      return { status: 'download_ready', approved, mediaIds: freshMediaIds };
+    }
+    if (freshMediaIds.length) {
+      await openGeneratedMedia(page, freshMediaIds);
+      return { status: 'media_ready', approved, mediaIds: freshMediaIds };
+    }
+    if (Date.now() - started >= readyProbeMs && Date.now() - lastReadyProbeAt >= readyProbeMs) {
+      lastReadyProbeAt = Date.now();
+      if (await probeDownloadableMedia(page, freshMediaIds)) {
+        return { status: 'download_ready', approved, mediaIds: freshMediaIds, probed: true };
+      }
+    }
+    if (await hasVisibleText(page, /\b\d{1,3}%\b|generating|currently in the queue|waiting in the queue|been scheduled|i['’]ve scheduled|ready for you shortly/i)) {
+      await page.waitForTimeout(intervalMs);
+      continue;
+    }
+    if (await hasText(page, /failed|oops, something went wrong/i)) {
+      return { status: 'failed', approved };
+    }
+    await page.waitForTimeout(intervalMs);
+  }
+  return { status: 'timeout', approved };
+}
+
+async function probeDownloadableMedia(page, mediaIds = []) {
+  if (await downloadButton(page).count().catch(() => 0)) return true;
+  await openGeneratedMedia(page, mediaIds);
+  await page.waitForTimeout(1000);
+  return (await downloadButton(page).count().catch(() => 0)) > 0;
+}
+
+async function hasVisibleText(page, pattern) {
+  return page.locator('body').evaluate((body, source) => {
+    const regex = new RegExp(source, 'i');
+    const isVisible = element => {
+      const style = window.getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      return style.visibility !== 'hidden' && style.display !== 'none' && rect.width > 0 && rect.height > 0;
+    };
+    const walker = document.createTreeWalker(body, NodeFilter.SHOW_ELEMENT);
+    let node = walker.nextNode();
+    while (node) {
+      const visibleChildCount = [...node.children].filter(isVisible).length;
+      if (visibleChildCount === 0 && isVisible(node) && regex.test(node.innerText || node.textContent || '')) {
+        return true;
+      }
+      node = walker.nextNode();
+    }
+    return false;
+  }, pattern.source).catch(() => false);
+}
+
+async function chooseDuration(page, requested) {
+  const options = [4, 6, 8, 10];
+  const closest = options.reduce((best, item) => (
+    Math.abs(item - requested) < Math.abs(best - requested) ? item : best
+  ), options[0]);
+  const option = page.getByText(new RegExp(`^${closest} seconds$`, 'i')).first();
+  if (await option.count().catch(() => 0)) await option.click({ timeout: 10000 }).catch(() => {});
+}
+
+async function clickApprove(page) {
+  const candidates = [
+    page.getByRole('button', { name: /^Approve$/i }).last(),
+    page.locator('button').filter({ hasText: /^Approve$/i }).last(),
+    page.locator('[role="button"]').filter({ hasText: /^Approve$/i }).last(),
+    page.locator('div,button,[role="button"]').filter({ hasText: /^\s*check\s*Approve\s*$/i }).last(),
+  ];
+  for (const locator of candidates) {
+    if (!(await locator.count().catch(() => 0))) continue;
+    try {
+      await locator.click({ timeout: 10000, force: true });
+      await page.waitForTimeout(1000);
+      const stillVisible = await page.getByRole('button', { name: /^Approve$/i })
+        .last()
+        .isVisible({ timeout: 1000 })
+        .catch(() => false);
+      if (!stillVisible || await hasVisibleText(page, /generating|currently in the queue|waiting in the queue|been scheduled|i['’]ve scheduled|ready for you shortly/i)) {
+        return true;
+      }
+    } catch {}
+  }
+  return false;
+}

package/plugins/takomi-flow/scripts/lib/flow-project-session.mjs

@@ -0,0 +1,153 @@
+import { FLOW_URL } from './paths.mjs';
+import { hasText, openFlow } from './flow-ui.mjs';
+
+export async function prepareProjectEditor(browser, request, result) {
+  const diagnostics = { projectUrl: undefined, recovered: false };
+  const waitMs = Number(request.editorWaitMs || process.env.TAKOMI_FLOW_EDITOR_WAIT_MS || 90000);
+
+  let mayUseCurrentProject = false;
+  if (request.projectUrl) {
+    browser.page = await openProjectUrl(browser, request.projectUrl);
+    mayUseCurrentProject = true;
+  } else if (request.reuseCurrentProject) {
+    browser.page = await findProjectPage(browser) || browser.page;
+    mayUseCurrentProject = true;
+  }
+
+  if (mayUseCurrentProject && isProjectUrl(browser.page.url())) {
+    const ready = await waitForProjectEditor(browser.page, waitMs);
+    diagnostics.projectUrl = browser.page.url();
+    return { ok: ready.ok, diagnostics, manualActions: ready.manualActions };
+  }
+
+  await openFlow(browser.page);
+  if (request.allowNewProject) {
+    const opened = await clickNewProject(browser.page);
+    if (!opened) {
+      return { ok: false, diagnostics, manualActions: ['New project button was not found. Open a Flow project manually, then retry with --project-url.'] };
+    }
+    const ready = await waitForProjectEditor(browser.page, waitMs);
+    diagnostics.projectUrl = browser.page.url();
+    return { ok: ready.ok, diagnostics, manualActions: ready.manualActions };
+  }
+
+  Object.assign(result, await currentFlowState(browser.page));
+  return {
+    ok: false,
+    diagnostics,
+    manualActions: ['Open an existing Flow project, pass --project-url, or set --allow-new-project to create a new Flow project.'],
+  };
+}
+
+export async function recoverFreshChat(page, request) {
+  if (!request.freshChatOnFailure) return { recovered: false, reason: 'freshChatOnFailure is disabled.' };
+  if (!isProjectUrl(page.url())) return { recovered: false, reason: 'Current page is not a Flow project.' };
+  const before = page.url();
+  await leaveMediaEditor(page);
+  const candidates = [
+    page.getByRole('button', { name: /new chat|new session|start new chat|new generation/i }).first(),
+    page.locator('button,[role="button"]').filter({ hasText: /new chat|new session|start new chat|new generation/i }).first(),
+    page.locator('[aria-label*="New chat" i], [aria-label*="New session" i], [aria-label*="Start new" i]').first(),
+  ];
+  for (const locator of candidates) {
+    if (!(await locator.count().catch(() => 0))) continue;
+    try {
+      await locator.click({ timeout: 10000 });
+      await page.waitForTimeout(1500);
+      const ready = await waitForProjectEditor(page, request.editorWaitMs || 60000);
+      return { recovered: ready.ok, reason: ready.ok ? 'fresh chat opened' : ready.manualActions.join(' ') };
+    } catch {}
+  }
+  if (await hasText(page, /oops|something went wrong|try again|chat failed/i)) {
+    await page.goto(projectBaseUrl(before), { waitUntil: 'domcontentloaded', timeout: 90000 }).catch(() => {});
+    const ready = await waitForProjectEditor(page, request.editorWaitMs || 60000);
+    return { recovered: ready.ok, reason: ready.ok ? 'project reloaded' : ready.manualActions.join(' ') };
+  }
+  return { recovered: false, reason: 'No same-project fresh chat control was found.' };
+}
+
+async function openProjectUrl(browser, projectUrl) {
+  const page = (await findProjectPage(browser, projectUrl)) || browser.page;
+  await page.goto(projectBaseUrl(projectUrl), { waitUntil: 'domcontentloaded', timeout: 90000 });
+  await page.waitForLoadState('networkidle', { timeout: 30000 }).catch(() => {});
+  await leaveMediaEditor(page);
+  return page;
+}
+
+async function findProjectPage(browser, exactUrl = undefined) {
+  const pages = browser.context.pages();
+  const match = pages.find(page => exactUrl ? page.url() === exactUrl : isProjectUrl(page.url()));
+  return match || null;
+}
+
+async function clickNewProject(page) {
+  const candidates = [
+    page.getByRole('button', { name: /new project/i }).first(),
+    page.locator('button').filter({ hasText: /new project/i }).first(),
+    page.getByText('New project').first(),
+  ];
+  for (const locator of candidates) {
+    if (!(await locator.count().catch(() => 0))) continue;
+    try {
+      await locator.click({ timeout: 10000 });
+      await page.waitForURL(/\/project\//, { timeout: 30000 }).catch(() => {});
+      await page.waitForLoadState('networkidle', { timeout: 30000 }).catch(() => {});
+      return isProjectUrl(page.url());
+    } catch {}
+  }
+  return false;
+}
+
+async function waitForProjectEditor(page, timeoutMs) {
+  await leaveMediaEditor(page);
+  await page.waitForLoadState('domcontentloaded', { timeout: 30000 }).catch(() => {});
+  await page.waitForLoadState('networkidle', { timeout: 30000 }).catch(() => {});
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const state = await currentFlowState(page);
+    if (state.manualActions.length) return { ok: false, manualActions: state.manualActions };
+    const hasEditorText = await hasText(page, /what do you want to create|start creating|add media/i);
+    const inputCount = await page.locator('div[role="textbox"], textarea:not(.g-recaptcha-response)').count().catch(() => 0);
+    if (hasEditorText && inputCount > 0) return { ok: true, manualActions: [] };
+    await page.waitForTimeout(1000);
+  }
+  return { ok: false, manualActions: ['Flow project editor did not become ready before the wait timeout.'] };
+}
+
+async function leaveMediaEditor(page) {
+  if (!/\/edit\//.test(page.url())) return;
+  const candidates = [
+    page.getByRole('button', { name: /^Done$/i }).last(),
+    page.locator('button').filter({ hasText: /^Done$/i }).last(),
+    page.getByRole('button', { name: /back/i }).first(),
+    page.locator('button').filter({ hasText: /arrow_back|back/i }).first(),
+  ];
+  for (const locator of candidates) {
+    if (!(await locator.count().catch(() => 0))) continue;
+    try {
+      await locator.click({ timeout: 10000, force: true });
+      await page.waitForURL(url => !/\/edit\//.test(url.toString()), { timeout: 15000 }).catch(() => {});
+      if (!/\/edit\//.test(page.url())) return;
+    } catch {}
+  }
+  await page.goto(projectBaseUrl(page.url()), { waitUntil: 'domcontentloaded', timeout: 90000 }).catch(() => {});
+}
+
+async function currentFlowState(page) {
+  const text = (await page.locator('body').innerText({ timeout: 5000 }).catch(() => '')).toLowerCase();
+  const manualActions = [];
+  if (text.includes('sign in') || text.includes('log in')) manualActions.push('Sign into Google/Flow in the opened browser.');
+  if (text.includes('captcha') || text.includes('verify')) manualActions.push('Complete the verification challenge in the browser.');
+  if (/quota|usage limit|not enough credits|insufficient credits|out of credits/.test(text)) {
+    manualActions.push('Review Flow quota or credits message in the browser.');
+  }
+  return { manualActions };
+}
+
+function isProjectUrl(url) {
+  return /\/project\//.test(url || '');
+}
+
+function projectBaseUrl(url) {
+  return String(url || '').replace(/\/edit\/[^/?#]+.*/, '');
+}