takomi 2.1.39 → 2.1.41

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

@@ -1,153 +1,153 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { defaultRunsDir, ensureDir, readJson, writeJson } from './paths.mjs';
-import { runDoctor } from './doctor.mjs';
-import { loadCapabilities } from './capabilities.mjs';
-import { loadTemplate } from './templates.mjs';
-import { createPreparedRequest } from './request.mjs';
-import { validateRequestFile } from './request-validator.mjs';
-import { createRun, saveResult, baseResult } from './result.mjs';
-import { catalogAssets } from './media.mjs';
-import { createReport } from './report.mjs';
-import { runWorkflow } from './workflow.mjs';
-import { reviewRun } from './review.mjs';
-import { runAudit } from './audit.mjs';
-import { collectRun } from './collect.mjs';
-import { loadExamples } from './examples.mjs';
-import { createAgentPlan } from './agent-plan.mjs';
-
-const execFileAsync = promisify(execFile);
-
-export async function runSelfTest(options = {}) {
-  const outputDir = path.resolve(options.outputDir || defaultRunsDir(), 'selftest');
-  ensureDir(outputDir);
-  const steps = [];
-  steps.push(await step('doctor', () => runDoctor({ outputDir })));
-  steps.push(await step('audit', () => runAudit({ outputDir })));
-  steps.push(await step('capabilities', () => loadCapabilities()));
-  steps.push(await step('examples', () => loadExamples('cinematic-video')));
-  steps.push(await step('agentPlan', () => createAgentPlan({
-    kind: 'video',
-    prompt: 'TakomiFlow self-test planned video prompt',
-    variations: 2,
-    aspectRatio: '16:9',
-    durationSeconds: 8,
-    extractFrames: 2,
-  })));
-  steps.push(await step('videoTemplate', () => loadTemplate('video')));
-  steps.push(await step('imageTemplate', () => loadTemplate('image')));
-  const prepared = await step('prepareAndValidate', () => prepareAndValidate(outputDir));
-  steps.push(prepared);
-  steps.push(await step('workflow', () => noSpendWorkflow(outputDir)));
-  steps.push(await step('settingsPlan', () => verifySettingsPlan(outputDir)));
-  steps.push(await step('guardedGenerate', () => guardedGenerate(prepared.data?.requestPath)));
-  const catalog = await step('assetCatalog', () => syntheticAssetCatalog(outputDir));
-  steps.push(catalog);
-  steps.push(await step('report', () => selftestReport(catalog.data?.runDir)));
-  steps.push(await step('review', () => selftestReview(catalog.data?.runDir)));
-  steps.push(await step('collect', () => selftestCollect(catalog.data?.runDir, outputDir)));
-  const failed = steps.some(item => item.status !== 'ok');
-  return {
-    schemaVersion: 1,
-    status: failed ? 'failed' : 'ok',
-    outputDir,
-    steps,
-  };
-}
-
-async function step(name, fn) {
-  try {
-    return { name, status: 'ok', data: await fn() };
-  } catch (error) {
-    return { name, status: 'failed', error: error.message };
-  }
-}
-
-function prepareAndValidate(outputDir) {
-  const { requestPath, request } = createPreparedRequest({
-    kind: 'video',
-    prompt: 'TakomiFlow self-test video prompt',
-    variations: 1,
-    'output-dir': outputDir,
-    'extract-frames': 2,
-  });
-  return { requestPath, request, validation: validateRequestFile(requestPath) };
-}
-
-function guardedGenerate(requestPath) {
-  if (!requestPath) throw new Error('No request path available.');
-  const request = readJson(requestPath);
-  if (request.allowSpend) throw new Error('Self-test request unexpectedly allows spend.');
-  return {
-    requestPath,
-    wouldSubmit: false,
-    reason: 'allowSpend is false, so generate must be blocked by the spend guard.',
-  };
-}
-
-async function noSpendWorkflow(outputDir) {
-  return runWorkflow({
-    kind: 'image',
-    prompt: 'TakomiFlow self-test image prompt',
-    variations: 1,
-    outputDir,
-  });
-}
-
-async function verifySettingsPlan(outputDir) {
-  const result = await runWorkflow({
-    kind: 'video',
-    prompt: 'TakomiFlow settings plan prompt',
-    variations: 2,
-    aspectRatio: '16:9',
-    durationSeconds: 8,
-    outputDir,
-  });
-  if (!result.settingsPlan?.selectorDependent?.length) {
-    throw new Error('Expected selector-dependent settings in workflow result.');
-  }
-  return result.settingsPlan;
-}
-
-async function syntheticAssetCatalog(outputDir) {
-  const run = createRun({ outputDir }, 'selftest-asset');
-  const videoPath = path.join(run.downloadsDir, 'sample.mp4');
-  await execFileAsync('ffmpeg', [
-    '-y',
-    '-f', 'lavfi',
-    '-i', 'testsrc=duration=2:size=320x180:rate=24',
-    '-c:v', 'libx264',
-    '-pix_fmt', 'yuv420p',
-    videoPath,
-  ]);
-  const result = baseResult('downloaded', run, {
-    command: 'selftest',
-    kind: 'video',
-    assets: [videoPath],
-  });
-  saveResult(run, result);
-  const catalog = await catalogAssets(run, [videoPath], { frames: 2 });
-  return { ...catalog, runDir: run.runDir };
-}
-
-function selftestReport(runDir) {
-  if (!runDir) throw new Error('No self-test run directory available.');
-  return createReport({ run: runDir });
-}
-
-async function selftestReview(runDir) {
-  if (!runDir) throw new Error('No self-test run directory available.');
-  return reviewRun({ run: runDir, frames: 2 });
-}
-
-async function selftestCollect(runDir, outputDir) {
-  if (!runDir) throw new Error('No self-test run directory available.');
-  return collectRun({
-    run: runDir,
-    targetDir: path.join(outputDir, 'collected'),
-    frames: 2,
-    includeFrames: true,
-  });
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { defaultRunsDir, ensureDir, readJson, writeJson } from './paths.mjs';
+import { runDoctor } from './doctor.mjs';
+import { loadCapabilities } from './capabilities.mjs';
+import { loadTemplate } from './templates.mjs';
+import { createPreparedRequest } from './request.mjs';
+import { validateRequestFile } from './request-validator.mjs';
+import { createRun, saveResult, baseResult } from './result.mjs';
+import { catalogAssets } from './media.mjs';
+import { createReport } from './report.mjs';
+import { runWorkflow } from './workflow.mjs';
+import { reviewRun } from './review.mjs';
+import { runAudit } from './audit.mjs';
+import { collectRun } from './collect.mjs';
+import { loadExamples } from './examples.mjs';
+import { createAgentPlan } from './agent-plan.mjs';
+
+const execFileAsync = promisify(execFile);
+
+export async function runSelfTest(options = {}) {
+  const outputDir = path.resolve(options.outputDir || defaultRunsDir(), 'selftest');
+  ensureDir(outputDir);
+  const steps = [];
+  steps.push(await step('doctor', () => runDoctor({ outputDir })));
+  steps.push(await step('audit', () => runAudit({ outputDir })));
+  steps.push(await step('capabilities', () => loadCapabilities()));
+  steps.push(await step('examples', () => loadExamples('cinematic-video')));
+  steps.push(await step('agentPlan', () => createAgentPlan({
+    kind: 'video',
+    prompt: 'TakomiFlow self-test planned video prompt',
+    variations: 2,
+    aspectRatio: '16:9',
+    durationSeconds: 8,
+    extractFrames: 2,
+  })));
+  steps.push(await step('videoTemplate', () => loadTemplate('video')));
+  steps.push(await step('imageTemplate', () => loadTemplate('image')));
+  const prepared = await step('prepareAndValidate', () => prepareAndValidate(outputDir));
+  steps.push(prepared);
+  steps.push(await step('workflow', () => noSpendWorkflow(outputDir)));
+  steps.push(await step('settingsPlan', () => verifySettingsPlan(outputDir)));
+  steps.push(await step('guardedGenerate', () => guardedGenerate(prepared.data?.requestPath)));
+  const catalog = await step('assetCatalog', () => syntheticAssetCatalog(outputDir));
+  steps.push(catalog);
+  steps.push(await step('report', () => selftestReport(catalog.data?.runDir)));
+  steps.push(await step('review', () => selftestReview(catalog.data?.runDir)));
+  steps.push(await step('collect', () => selftestCollect(catalog.data?.runDir, outputDir)));
+  const failed = steps.some(item => item.status !== 'ok');
+  return {
+    schemaVersion: 1,
+    status: failed ? 'failed' : 'ok',
+    outputDir,
+    steps,
+  };
+}
+
+async function step(name, fn) {
+  try {
+    return { name, status: 'ok', data: await fn() };
+  } catch (error) {
+    return { name, status: 'failed', error: error.message };
+  }
+}
+
+function prepareAndValidate(outputDir) {
+  const { requestPath, request } = createPreparedRequest({
+    kind: 'video',
+    prompt: 'TakomiFlow self-test video prompt',
+    variations: 1,
+    'output-dir': outputDir,
+    'extract-frames': 2,
+  });
+  return { requestPath, request, validation: validateRequestFile(requestPath) };
+}
+
+function guardedGenerate(requestPath) {
+  if (!requestPath) throw new Error('No request path available.');
+  const request = readJson(requestPath);
+  if (request.allowSpend) throw new Error('Self-test request unexpectedly allows spend.');
+  return {
+    requestPath,
+    wouldSubmit: false,
+    reason: 'allowSpend is false, so generate must be blocked by the spend guard.',
+  };
+}
+
+async function noSpendWorkflow(outputDir) {
+  return runWorkflow({
+    kind: 'image',
+    prompt: 'TakomiFlow self-test image prompt',
+    variations: 1,
+    outputDir,
+  });
+}
+
+async function verifySettingsPlan(outputDir) {
+  const result = await runWorkflow({
+    kind: 'video',
+    prompt: 'TakomiFlow settings plan prompt',
+    variations: 2,
+    aspectRatio: '16:9',
+    durationSeconds: 8,
+    outputDir,
+  });
+  if (!result.settingsPlan?.selectorDependent?.length) {
+    throw new Error('Expected selector-dependent settings in workflow result.');
+  }
+  return result.settingsPlan;
+}
+
+async function syntheticAssetCatalog(outputDir) {
+  const run = createRun({ outputDir }, 'selftest-asset');
+  const videoPath = path.join(run.downloadsDir, 'sample.mp4');
+  await execFileAsync('ffmpeg', [
+    '-y',
+    '-f', 'lavfi',
+    '-i', 'testsrc=duration=2:size=320x180:rate=24',
+    '-c:v', 'libx264',
+    '-pix_fmt', 'yuv420p',
+    videoPath,
+  ]);
+  const result = baseResult('downloaded', run, {
+    command: 'selftest',
+    kind: 'video',
+    assets: [videoPath],
+  });
+  saveResult(run, result);
+  const catalog = await catalogAssets(run, [videoPath], { frames: 2 });
+  return { ...catalog, runDir: run.runDir };
+}
+
+function selftestReport(runDir) {
+  if (!runDir) throw new Error('No self-test run directory available.');
+  return createReport({ run: runDir });
+}
+
+async function selftestReview(runDir) {
+  if (!runDir) throw new Error('No self-test run directory available.');
+  return reviewRun({ run: runDir, frames: 2 });
+}
+
+async function selftestCollect(runDir, outputDir) {
+  if (!runDir) throw new Error('No self-test run directory available.');
+  return collectRun({
+    run: runDir,
+    targetDir: path.join(outputDir, 'collected'),
+    frames: 2,
+    includeFrames: true,
+  });
+}

package/plugins/takomi-flow/scripts/lib/settings-plan.mjs

@@ -1,39 +1,44 @@
-export function createSettingsPlan(request) {
-  const requested = {
-    kind: request.kind,
-    mode: request.mode,
-    variations: request.variations,
-    aspectRatio: request.aspectRatio,
-    durationSeconds: request.durationSeconds,
-    modelHint: request.modelHint,
-    extractFrames: request.extractFrames,
-    sourceAssets: request.sourceAssets || [],
-  };
-  const automatic = ['prompt', 'download folder', 'metadata', 'asset catalog'];
-  if (request.extractFrames > 0) automatic.push('video review frame extraction after download');
-  return {
-    schemaVersion: 1,
-    requested,
-    automatic,
-    selectorDependent: selectorDependent(request),
-    notes: [
-      'Prompt submission and downloads are automated through public Flow UI selectors.',
-      'Visual settings remain explicit in metadata until live Flow controls are observed and selector coverage is tuned.',
-    ],
-  };
-}
-
-function selectorDependent(request) {
-  const items = [];
-  if (request.mode) items.push({ field: 'mode', value: request.mode });
-  if (request.aspectRatio) items.push({ field: 'aspectRatio', value: request.aspectRatio });
-  if (request.durationSeconds) items.push({ field: 'durationSeconds', value: request.durationSeconds });
-  if (request.modelHint && request.modelHint !== 'best-available') {
-    items.push({ field: 'modelHint', value: request.modelHint });
-  }
-  if (request.sourceAssets?.length) {
-    items.push({ field: 'sourceAssets', value: request.sourceAssets });
-  }
-  if (request.variations > 1) items.push({ field: 'variations', value: request.variations });
-  return items;
-}
+export function createSettingsPlan(request) {
+  const requested = {
+    kind: request.kind,
+    mode: request.mode,
+    variations: request.variations,
+    aspectRatio: request.aspectRatio,
+    durationSeconds: request.durationSeconds,
+    modelHint: request.modelHint,
+    extractFrames: request.extractFrames,
+    sourceAssets: request.sourceAssets || [],
+    projectUrl: request.projectUrl,
+    reuseCurrentProject: request.reuseCurrentProject,
+    allowNewProject: request.allowNewProject,
+    freshChatOnFailure: request.freshChatOnFailure,
+    editorWaitMs: request.editorWaitMs,
+  };
+  const automatic = ['prompt', 'project reuse', 'same-project chat recovery', 'download folder', 'metadata', 'asset catalog'];
+  if (request.extractFrames > 0) automatic.push('video review frame extraction after download');
+  return {
+    schemaVersion: 1,
+    requested,
+    automatic,
+    selectorDependent: selectorDependent(request),
+    notes: [
+      'Prompt submission and downloads are automated through public Flow UI selectors.',
+      'Visual settings remain explicit in metadata until live Flow controls are observed and selector coverage is tuned.',
+    ],
+  };
+}
+
+function selectorDependent(request) {
+  const items = [];
+  if (request.mode) items.push({ field: 'mode', value: request.mode });
+  if (request.aspectRatio) items.push({ field: 'aspectRatio', value: request.aspectRatio });
+  if (request.durationSeconds) items.push({ field: 'durationSeconds', value: request.durationSeconds });
+  if (request.modelHint && request.modelHint !== 'best-available') {
+    items.push({ field: 'modelHint', value: request.modelHint });
+  }
+  if (request.sourceAssets?.length) {
+    items.push({ field: 'sourceAssets', value: request.sourceAssets });
+  }
+  if (request.variations > 1) items.push({ field: 'variations', value: request.variations });
+  return items;
+}

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

@@ -1,37 +1,37 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { ensureDir, writeJson } from './paths.mjs';
-
-const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
-const PLUGIN_ROOT = path.resolve(MODULE_DIR, '..', '..');
-const TEMPLATE_DIR = path.join(PLUGIN_ROOT, 'assets', 'templates');
-const TEMPLATES = {
-  video: 'video-request.json',
-  image: 'image-request.json',
-};
-
-export function listTemplates() {
-  return Object.keys(TEMPLATES).map(kind => ({ kind, path: templatePath(kind) }));
-}
-
-export function loadTemplate(kind) {
-  const filePath = templatePath(kind);
-  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-}
-
-export function writeTemplate(kind, outputDir) {
-  const template = loadTemplate(kind);
-  const destinationDir = ensureDir(path.resolve(outputDir));
-  const destination = path.join(destinationDir, TEMPLATES[kind]);
-  writeJson(destination, template);
-  return { kind, destination, template };
-}
-
-function templatePath(kind) {
-  const fileName = TEMPLATES[String(kind || '').toLowerCase()];
-  if (!fileName) {
-    throw new Error(`Unknown template "${kind}". Expected image or video.`);
-  }
-  return path.join(TEMPLATE_DIR, fileName);
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureDir, writeJson } from './paths.mjs';
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = path.resolve(MODULE_DIR, '..', '..');
+const TEMPLATE_DIR = path.join(PLUGIN_ROOT, 'assets', 'templates');
+const TEMPLATES = {
+  video: 'video-request.json',
+  image: 'image-request.json',
+};
+
+export function listTemplates() {
+  return Object.keys(TEMPLATES).map(kind => ({ kind, path: templatePath(kind) }));
+}
+
+export function loadTemplate(kind) {
+  const filePath = templatePath(kind);
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+export function writeTemplate(kind, outputDir) {
+  const template = loadTemplate(kind);
+  const destinationDir = ensureDir(path.resolve(outputDir));
+  const destination = path.join(destinationDir, TEMPLATES[kind]);
+  writeJson(destination, template);
+  return { kind, destination, template };
+}
+
+function templatePath(kind) {
+  const fileName = TEMPLATES[String(kind || '').toLowerCase()];
+  if (!fileName) {
+    throw new Error(`Unknown template "${kind}". Expected image or video.`);
+  }
+  return path.join(TEMPLATE_DIR, fileName);
+}

package/plugins/takomi-flow/scripts/lib/trusted-chrome.mjs

@@ -1,67 +1,67 @@
-import os from 'node:os';
-import path from 'node:path';
-import fs from 'node:fs';
-import { spawn } from 'node:child_process';
-import { ensureDir, FLOW_URL } from './paths.mjs';
-
-export function defaultTrustedProfileDir() {
-  return path.join(os.homedir(), '.takomi-flow', 'trusted-chrome-profile');
-}
-
-export function launchTrustedChrome(args = {}) {
-  const port = Number.parseInt(args.port || '9222', 10) || 9222;
-  const userDataDir = ensureDir(path.resolve(args.profileDir || defaultTrustedProfileDir()));
-  const executable = args.chromePath || findChromeExecutable();
-  const chromeArgs = [
-    `--remote-debugging-port=${port}`,
-    `--user-data-dir=${userDataDir}`,
-    '--no-first-run',
-    '--new-window',
-    args.url || FLOW_URL,
-  ];
-  if (args.printCommand) {
-    return result({ executable, chromeArgs, port, userDataDir, launched: false });
-  }
-  const child = spawn(executable, chromeArgs, {
-    detached: true,
-    stdio: 'ignore',
-    windowsHide: false,
-  });
-  child.unref();
-  return result({ executable, chromeArgs, port, userDataDir, launched: true, processId: child.pid });
-}
-
-function result(data) {
-  return {
-    schemaVersion: 1,
-    status: 'ok',
-    cdpUrl: `http://127.0.0.1:${data.port}`,
-    loginUrl: data.chromeArgs[data.chromeArgs.length - 1],
-    userDataDir: data.userDataDir,
-    executable: data.executable,
-    args: data.chromeArgs,
-    launched: data.launched,
-    processId: data.processId,
-    nextActions: [
-      'Log into Google Flow manually in the opened Chrome window.',
-      `After login, use --cdp-url http://127.0.0.1:${data.port} with observe, smoke, workflow, or generate.`,
-      'Keep this Chrome window open while TakomiFlow attaches to it.',
-    ],
-  };
-}
-
-function findChromeExecutable() {
-  const candidates = process.platform === 'win32' ? [
-    path.join(process.env.PROGRAMFILES || 'C:\\Program Files', 'Google', 'Chrome', 'Application', 'chrome.exe'),
-    path.join(process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)', 'Google', 'Chrome', 'Application', 'chrome.exe'),
-    path.join(process.env.LOCALAPPDATA || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
-  ] : [
-    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-    '/usr/bin/google-chrome',
-    '/usr/bin/google-chrome-stable',
-    '/usr/bin/chromium-browser',
-  ];
-  const found = candidates.find(candidate => candidate && fs.existsSync(candidate));
-  if (!found) throw new Error('Could not find Chrome. Pass --chrome-path <path-to-chrome>.');
-  return found;
-}
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import { ensureDir, FLOW_URL } from './paths.mjs';
+
+export function defaultTrustedProfileDir() {
+  return path.join(os.homedir(), '.takomi-flow', 'trusted-chrome-profile');
+}
+
+export function launchTrustedChrome(args = {}) {
+  const port = Number.parseInt(args.port || '9222', 10) || 9222;
+  const userDataDir = ensureDir(path.resolve(args.profileDir || defaultTrustedProfileDir()));
+  const executable = args.chromePath || findChromeExecutable();
+  const chromeArgs = [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${userDataDir}`,
+    '--no-first-run',
+    '--new-window',
+    args.url || FLOW_URL,
+  ];
+  if (args.printCommand) {
+    return result({ executable, chromeArgs, port, userDataDir, launched: false });
+  }
+  const child = spawn(executable, chromeArgs, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: false,
+  });
+  child.unref();
+  return result({ executable, chromeArgs, port, userDataDir, launched: true, processId: child.pid });
+}
+
+function result(data) {
+  return {
+    schemaVersion: 1,
+    status: 'ok',
+    cdpUrl: `http://127.0.0.1:${data.port}`,
+    loginUrl: data.chromeArgs[data.chromeArgs.length - 1],
+    userDataDir: data.userDataDir,
+    executable: data.executable,
+    args: data.chromeArgs,
+    launched: data.launched,
+    processId: data.processId,
+    nextActions: [
+      'Log into Google Flow manually in the opened Chrome window.',
+      `After login, use --cdp-url http://127.0.0.1:${data.port} with observe, smoke, workflow, or generate.`,
+      'Keep this Chrome window open while TakomiFlow attaches to it.',
+    ],
+  };
+}
+
+function findChromeExecutable() {
+  const candidates = process.platform === 'win32' ? [
+    path.join(process.env.PROGRAMFILES || 'C:\\Program Files', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+    path.join(process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+    path.join(process.env.LOCALAPPDATA || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+  ] : [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/usr/bin/google-chrome',
+    '/usr/bin/google-chrome-stable',
+    '/usr/bin/chromium-browser',
+  ];
+  const found = candidates.find(candidate => candidate && fs.existsSync(candidate));
+  if (!found) throw new Error('Could not find Chrome. Pass --chrome-path <path-to-chrome>.');
+  return found;
+}