takomi 2.1.39 → 2.1.41

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

@@ -1,65 +1,65 @@
-import fs from 'node:fs';
-import { runDoctor } from './doctor.mjs';
-import { loadCapabilities } from './capabilities.mjs';
-import { listRuns } from './inspect.mjs';
-
-export async function runAudit(args = {}) {
-  const doctor = await runDoctor({
-    profileDir: args.profileDir,
-    outputDir: args.outputDir,
-  });
-  const capabilities = loadCapabilities();
-  const history = listRuns(doctor.outputDir, args.limit || 5);
-  const profileReady = fs.existsSync(doctor.profileDir);
-  const browserReady = doctor.checks.every(check => (
-    check.name === 'profileDir' || check.status !== 'failed'
-  ));
-  return {
-    schemaVersion: 1,
-    status: doctor.status === 'failed' ? 'failed' : 'ok',
-    readiness: {
-      browserAutomation: browserReady,
-      flowProfile: profileReady,
-      mediaReview: hasCheck(doctor, 'ffmpeg') && hasCheck(doctor, 'ffprobe'),
-      mcpTools: capabilities.mcpTools.length,
-      mcpResources: capabilities.mcpResources.length,
-    },
-    safeActions: [
-      'capabilities',
-      'examples',
-      'plan',
-      'template',
-      'workflow without submit',
-      'validate',
-      'runs',
-      'inspect',
-      'assets',
-      'review',
-      'collect',
-      'report',
-      'selftest',
-    ],
-    gatedActions: [
-      'bootstrap requires a headed browser and manual Google login',
-      'observe requires allowBrowser=true',
-      'generate requires allowBrowser=true and allowSpend=true',
-      'workflow submit requires allowBrowser=true and allowSpend=true',
-    ],
-    doctor,
-    recentRuns: history.runs,
-    nextActions: nextActions(doctor, profileReady, history.runs),
-  };
-}
-
-function hasCheck(doctor, name) {
-  return doctor.checks.some(check => check.name === name && check.status === 'ok');
-}
-
-function nextActions(doctor, profileReady, runs) {
-  const actions = [...doctor.recommendations];
-  if (!profileReady) actions.push('Run bootstrap in headed mode and log into Google Flow manually.');
-  if (!runs.length) actions.push('Run workflow to prepare the first request, or smoke after login.');
-  if (runs.some(run => run.status === 'downloaded')) actions.push('Run review on downloaded runs before reusing assets.');
-  if (!actions.length) actions.push('TakomiFlow is ready for safe no-spend workflow preparation.');
-  return [...new Set(actions)];
-}
+import fs from 'node:fs';
+import { runDoctor } from './doctor.mjs';
+import { loadCapabilities } from './capabilities.mjs';
+import { listRuns } from './inspect.mjs';
+
+export async function runAudit(args = {}) {
+  const doctor = await runDoctor({
+    profileDir: args.profileDir,
+    outputDir: args.outputDir,
+  });
+  const capabilities = loadCapabilities();
+  const history = listRuns(doctor.outputDir, args.limit || 5);
+  const profileReady = fs.existsSync(doctor.profileDir);
+  const browserReady = doctor.checks.every(check => (
+    check.name === 'profileDir' || check.status !== 'failed'
+  ));
+  return {
+    schemaVersion: 1,
+    status: doctor.status === 'failed' ? 'failed' : 'ok',
+    readiness: {
+      browserAutomation: browserReady,
+      flowProfile: profileReady,
+      mediaReview: hasCheck(doctor, 'ffmpeg') && hasCheck(doctor, 'ffprobe'),
+      mcpTools: capabilities.mcpTools.length,
+      mcpResources: capabilities.mcpResources.length,
+    },
+    safeActions: [
+      'capabilities',
+      'examples',
+      'plan',
+      'template',
+      'workflow without submit',
+      'validate',
+      'runs',
+      'inspect',
+      'assets',
+      'review',
+      'collect',
+      'report',
+      'selftest',
+    ],
+    gatedActions: [
+      'bootstrap requires a headed browser and manual Google login',
+      'observe requires allowBrowser=true',
+      'generate requires allowBrowser=true and allowSpend=true',
+      'workflow submit requires allowBrowser=true and allowSpend=true',
+    ],
+    doctor,
+    recentRuns: history.runs,
+    nextActions: nextActions(doctor, profileReady, history.runs),
+  };
+}
+
+function hasCheck(doctor, name) {
+  return doctor.checks.some(check => check.name === name && check.status === 'ok');
+}
+
+function nextActions(doctor, profileReady, runs) {
+  const actions = [...doctor.recommendations];
+  if (!profileReady) actions.push('Run bootstrap in headed mode and log into Google Flow manually.');
+  if (!runs.length) actions.push('Run workflow to prepare the first request, or smoke after login.');
+  if (runs.some(run => run.status === 'downloaded')) actions.push('Run review on downloaded runs before reusing assets.');
+  if (!actions.length) actions.push('TakomiFlow is ready for safe no-spend workflow preparation.');
+  return [...new Set(actions)];
+}

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

@@ -1,39 +1,78 @@
-import path from 'node:path';
-import { ensureDir } from './paths.mjs';
-import { loadPlaywright } from './playwright-loader.mjs';
-
-export async function launchFlowBrowser(options = {}) {
-  const { chromium } = await loadPlaywright();
-  const profileDir = ensureDir(path.resolve(options.profileDir));
-  const downloadsDir = ensureDir(path.resolve(options.downloadsDir));
-  const headless = options.headless === true;
-  if (options.cdpUrl) {
-    const browser = await chromium.connectOverCDP(options.cdpUrl);
-    const context = browser.contexts()[0] || await browser.newContext({ acceptDownloads: true });
-    const page = context.pages()[0] || await context.newPage();
-    return { browser, context, page, profileDir, downloadsDir, cdpUrl: options.cdpUrl, attached: true };
-  }
-  const channel = options.browserChannel || process.env.TAKOMI_FLOW_BROWSER_CHANNEL || defaultBrowserChannel();
-  const context = await chromium.launchPersistentContext(profileDir, {
-    headless,
-    ...(channel ? { channel } : {}),
-    acceptDownloads: true,
-    downloadsPath: downloadsDir,
-    viewport: { width: 1440, height: 960 },
-  });
-  const page = context.pages()[0] || await context.newPage();
-  return { context, page, profileDir, downloadsDir, browserChannel: channel };
-}
-
-export async function closeFlowBrowser(browser) {
-  if (browser.attached) {
-    await browser.browser?.close?.().catch(() => {});
-    return;
-  }
-  await browser.context.close().catch(() => {});
-}
-
-function defaultBrowserChannel() {
-  if (process.platform === 'win32' || process.platform === 'darwin') return 'chrome';
-  return undefined;
-}
+import path from 'node:path';
+import { ensureDir } from './paths.mjs';
+import { loadPlaywright } from './playwright-loader.mjs';
+import { launchTrustedChrome } from './trusted-chrome.mjs';
+
+const DEFAULT_CDP_URL = 'http://127.0.0.1:9222';
+
+export async function launchFlowBrowser(options = {}) {
+  const { chromium } = await loadPlaywright();
+  const profileDir = ensureDir(path.resolve(options.profileDir));
+  const downloadsDir = ensureDir(path.resolve(options.downloadsDir));
+  const headless = options.headless === true;
+  const trustedCdpUrl = await trustedChromeCdpUrl(options);
+  if (trustedCdpUrl) {
+    const browser = await chromium.connectOverCDP(trustedCdpUrl);
+    const context = browser.contexts()[0] || await browser.newContext({ acceptDownloads: true });
+    const page = context.pages()[0] || await context.newPage();
+    return { browser, context, page, profileDir, downloadsDir, cdpUrl: trustedCdpUrl, attached: true };
+  }
+  const channel = options.browserChannel || process.env.TAKOMI_FLOW_BROWSER_CHANNEL || defaultBrowserChannel();
+  const context = await chromium.launchPersistentContext(profileDir, {
+    headless,
+    ...(channel ? { channel } : {}),
+    acceptDownloads: true,
+    downloadsPath: downloadsDir,
+    viewport: { width: 1440, height: 960 },
+  });
+  const page = context.pages()[0] || await context.newPage();
+  return { context, page, profileDir, downloadsDir, browserChannel: channel };
+}
+
+export async function closeFlowBrowser(browser) {
+  if (browser.attached) {
+    if (typeof browser.browser?.disconnect === 'function') {
+      browser.browser.disconnect();
+      return;
+    }
+    await browser.browser?.close?.().catch(() => {});
+    return;
+  }
+  await browser.context.close().catch(() => {});
+}
+
+async function trustedChromeCdpUrl(options) {
+  if (options.cdpUrl) return options.cdpUrl;
+  if (options.headless === true || options.usePlaywrightBrowser === true) return null;
+  if (await canConnect(DEFAULT_CDP_URL)) return DEFAULT_CDP_URL;
+  try {
+    const trusted = launchTrustedChrome({ url: options.url });
+    return await waitForCdp(trusted.cdpUrl);
+  } catch {
+    return null;
+  }
+}
+
+async function waitForCdp(cdpUrl) {
+  const timeoutMs = 10000;
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    if (await canConnect(cdpUrl)) return cdpUrl;
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+  return null;
+}
+
+async function canConnect(cdpUrl) {
+  try {
+    const response = await fetch(`${cdpUrl}/json/version`, { signal: AbortSignal.timeout(2000) });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+function defaultBrowserChannel() {
+  if (process.platform === 'win32' || process.platform === 'darwin') return 'chrome';
+  return undefined;
+}

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

@@ -1,11 +1,11 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
-const PLUGIN_ROOT = path.resolve(MODULE_DIR, '..', '..');
-const CAPABILITIES_PATH = path.join(PLUGIN_ROOT, 'assets', 'capabilities.json');
-
-export function loadCapabilities() {
-  return JSON.parse(fs.readFileSync(CAPABILITIES_PATH, 'utf8'));
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = path.resolve(MODULE_DIR, '..', '..');
+const CAPABILITIES_PATH = path.join(PLUGIN_ROOT, 'assets', 'capabilities.json');
+
+export function loadCapabilities() {
+  return JSON.parse(fs.readFileSync(CAPABILITIES_PATH, 'utf8'));
+}

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

@@ -1,53 +1,53 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { ensureDir, writeJson } from './paths.mjs';
-import { reviewRun } from './review.mjs';
-
-export async function collectRun(args = {}) {
-  if (!args.run) throw new Error('collect requires --run <run.json|run-dir>');
-  if (!args.targetDir) throw new Error('collect requires --target-dir <path>');
-  const targetDir = ensureDir(path.resolve(args.targetDir));
-  const review = await reviewRun({
-    run: args.run,
-    frames: args.frames || 0,
-    reportPath: args.reportPath,
-  });
-  const copied = [];
-  for (const asset of review.catalog.assets || []) {
-    if (asset.exists) copied.push(copyFile(asset.path, path.join(targetDir, 'assets')));
-    if (args.includeFrames) {
-      for (const frame of asset.frames || []) copied.push(copyFile(frame, path.join(targetDir, 'frames')));
-    }
-  }
-  if (review.reportPath && fs.existsSync(review.reportPath)) {
-    copied.push(copyFile(review.reportPath, targetDir, 'report.md'));
-  }
-  const manifest = {
-    schemaVersion: 1,
-    status: copied.length ? 'collected' : 'empty',
-    runId: review.runId,
-    sourceRunDir: review.runDir,
-    targetDir,
-    copied,
-    review,
-  };
-  manifest.manifestPath = writeJson(path.join(targetDir, 'takomi-flow-collection.json'), manifest);
-  return manifest;
-}
-
-function copyFile(source, targetDir, name = path.basename(source)) {
-  ensureDir(targetDir);
-  const target = uniquePath(path.join(targetDir, name));
-  fs.copyFileSync(source, target);
-  return { source, target };
-}
-
-function uniquePath(filePath) {
-  if (!fs.existsSync(filePath)) return filePath;
-  const parsed = path.parse(filePath);
-  for (let i = 1; i < 1000; i += 1) {
-    const candidate = path.join(parsed.dir, `${parsed.name}-${i}${parsed.ext}`);
-    if (!fs.existsSync(candidate)) return candidate;
-  }
-  throw new Error(`Could not create unique path for ${filePath}`);
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { ensureDir, writeJson } from './paths.mjs';
+import { reviewRun } from './review.mjs';
+
+export async function collectRun(args = {}) {
+  if (!args.run) throw new Error('collect requires --run <run.json|run-dir>');
+  if (!args.targetDir) throw new Error('collect requires --target-dir <path>');
+  const targetDir = ensureDir(path.resolve(args.targetDir));
+  const review = await reviewRun({
+    run: args.run,
+    frames: args.frames || 0,
+    reportPath: args.reportPath,
+  });
+  const copied = [];
+  for (const asset of review.catalog.assets || []) {
+    if (asset.exists) copied.push(copyFile(asset.path, path.join(targetDir, 'assets')));
+    if (args.includeFrames) {
+      for (const frame of asset.frames || []) copied.push(copyFile(frame, path.join(targetDir, 'frames')));
+    }
+  }
+  if (review.reportPath && fs.existsSync(review.reportPath)) {
+    copied.push(copyFile(review.reportPath, targetDir, 'report.md'));
+  }
+  const manifest = {
+    schemaVersion: 1,
+    status: copied.length ? 'collected' : 'empty',
+    runId: review.runId,
+    sourceRunDir: review.runDir,
+    targetDir,
+    copied,
+    review,
+  };
+  manifest.manifestPath = writeJson(path.join(targetDir, 'takomi-flow-collection.json'), manifest);
+  return manifest;
+}
+
+function copyFile(source, targetDir, name = path.basename(source)) {
+  ensureDir(targetDir);
+  const target = uniquePath(path.join(targetDir, name));
+  fs.copyFileSync(source, target);
+  return { source, target };
+}
+
+function uniquePath(filePath) {
+  if (!fs.existsSync(filePath)) return filePath;
+  const parsed = path.parse(filePath);
+  for (let i = 1; i < 1000; i += 1) {
+    const candidate = path.join(parsed.dir, `${parsed.name}-${i}${parsed.ext}`);
+    if (!fs.existsSync(candidate)) return candidate;
+  }
+  throw new Error(`Could not create unique path for ${filePath}`);
+}