takomi 2.1.39 → 2.1.41

package/plugins/takomi-flow/scripts/lib/request-validator.mjs

@@ -1,58 +1,73 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { loadCapabilities } from './capabilities.mjs';
-import { normalizeRequest } from './request.mjs';
-
-export function validateRequestFile(requestPath) {
-  if (!requestPath) throw new Error('validate requires --request <path>');
-  const absolutePath = path.resolve(requestPath);
-  const raw = JSON.parse(fs.readFileSync(absolutePath, 'utf8'));
-  return validateRequest(raw, absolutePath);
-}
-
-export function validateRequest(raw, requestPath = undefined) {
-  const capabilities = loadCapabilities();
-  const errors = [];
-  const warnings = [];
-  let normalized;
-  try {
-    normalized = normalizeRequest(raw);
-  } catch (error) {
-    return {
-      schemaVersion: 1,
-      status: 'failed',
-      requestPath,
-      errors: [error.message],
-      warnings,
-    };
-  }
-  if (!capabilities.kinds.includes(normalized.kind)) {
-    errors.push(`Unsupported kind: ${normalized.kind}`);
-  }
-  const allowedModes = capabilities.modes[normalized.kind] || [];
-  if (normalized.mode && !allowedModes.includes(normalized.mode)) {
-    warnings.push(`Mode "${normalized.mode}" is not listed for kind "${normalized.kind}".`);
-  }
-  if (normalized.variations > capabilities.variations.max) {
-    warnings.push(`Variations ${normalized.variations} exceeds listed max ${capabilities.variations.max}.`);
-  }
-  if (normalized.aspectRatio && !capabilities.aspectRatios.includes(normalized.aspectRatio)) {
-    warnings.push(`Aspect ratio "${normalized.aspectRatio}" is not in listed options.`);
-  }
-  for (const asset of normalized.sourceAssets) {
-    if (!fs.existsSync(path.resolve(asset))) {
-      errors.push(`Source asset does not exist: ${asset}`);
-    }
-  }
-  if (!normalized.allowSpend) {
-    warnings.push('Spend guard is off. Generation will not submit until allowSpend=true or TAKOMI_FLOW_ALLOW_SPEND=true.');
-  }
-  return {
-    schemaVersion: 1,
-    status: errors.length ? 'failed' : 'ok',
-    requestPath,
-    normalized,
-    errors,
-    warnings,
-  };
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadCapabilities } from './capabilities.mjs';
+import { normalizeRequest } from './request.mjs';
+
+export function validateRequestFile(requestPath) {
+  if (!requestPath) throw new Error('validate requires --request <path>');
+  const absolutePath = path.resolve(requestPath);
+  const raw = JSON.parse(fs.readFileSync(absolutePath, 'utf8'));
+  return validateRequest(raw, absolutePath);
+}
+
+export function validateRequest(raw, requestPath = undefined) {
+  const capabilities = loadCapabilities();
+  const errors = [];
+  const warnings = [];
+  let normalized;
+  try {
+    normalized = normalizeRequest(raw);
+  } catch (error) {
+    return {
+      schemaVersion: 1,
+      status: 'failed',
+      requestPath,
+      errors: [error.message],
+      warnings,
+    };
+  }
+  if (!capabilities.kinds.includes(normalized.kind)) {
+    errors.push(`Unsupported kind: ${normalized.kind}`);
+  }
+  const allowedModes = capabilities.modes[normalized.kind] || [];
+  if (normalized.mode && !allowedModes.includes(normalized.mode)) {
+    warnings.push(`Mode "${normalized.mode}" is not listed for kind "${normalized.kind}".`);
+  }
+  if (normalized.variations > capabilities.variations.max) {
+    warnings.push(`Variations ${normalized.variations} exceeds listed max ${capabilities.variations.max}.`);
+  }
+  if (normalized.aspectRatio && !capabilities.aspectRatios.includes(normalized.aspectRatio)) {
+    warnings.push(`Aspect ratio "${normalized.aspectRatio}" is not in listed options.`);
+  }
+  if (normalized.projectUrl && !isFlowProjectUrl(normalized.projectUrl)) {
+    errors.push(`Project URL must be a Google Flow project URL: ${normalized.projectUrl}`);
+  }
+  if (normalized.editorWaitMs !== undefined && normalized.editorWaitMs < 1000) {
+    errors.push('editorWaitMs must be at least 1000 milliseconds.');
+  }
+  for (const asset of normalized.sourceAssets) {
+    if (!fs.existsSync(path.resolve(asset))) {
+      errors.push(`Source asset does not exist: ${asset}`);
+    }
+  }
+  if (!normalized.allowSpend) {
+    warnings.push('Spend guard is off. Generation will not submit until allowSpend=true or TAKOMI_FLOW_ALLOW_SPEND=true.');
+  }
+  return {
+    schemaVersion: 1,
+    status: errors.length ? 'failed' : 'ok',
+    requestPath,
+    normalized,
+    errors,
+    warnings,
+  };
+}
+
+function isFlowProjectUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.hostname === 'labs.google' && url.pathname.includes('/fx/tools/flow/project/');
+  } catch {
+    return false;
+  }
+}

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

@@ -1,55 +1,66 @@
-import path from 'node:path';
-import { defaultRunsDir, ensureDir, timestampId, writeJson } from './paths.mjs';
-
-const VALID_KINDS = new Set(['video', 'image']);
-
-export function normalizeRequest(input) {
-  const kind = String(input.kind || 'video').toLowerCase();
-  if (!VALID_KINDS.has(kind)) {
-    throw new Error(`Invalid kind "${kind}". Expected video or image.`);
-  }
-  const prompt = String(input.prompt || '').trim();
-  if (!prompt) {
-    throw new Error('A non-empty prompt is required.');
-  }
-  const variations = Math.max(1, Number.parseInt(input.variations || '1', 10) || 1);
-  return {
-    schemaVersion: 1,
-    kind,
-    prompt,
-    variations,
-    aspectRatio: input.aspectRatio || input['aspect-ratio'] || undefined,
-    durationSeconds: toOptionalNumber(input.durationSeconds || input.duration),
-    mode: input.mode || (kind === 'video' ? 'text-to-video' : 'text-to-image'),
-    modelHint: input.modelHint || input.model || 'best-available',
-    outputDir: path.resolve(input.outputDir || input['output-dir'] || defaultRunsDir()),
-    allowSpend: Boolean(input.allowSpend || input['allow-spend'] || false),
-    extractFrames: Math.max(0, Number.parseInt(input.extractFrames || input['extract-frames'] || '0', 10) || 0),
-    sourceAssets: normalizeList(input.sourceAssets || input.assets),
-    notes: input.notes || undefined,
-  };
-}
-
-export function createPreparedRequest(args) {
-  const request = normalizeRequest(args);
-  const requestDir = ensureDir(path.join(request.outputDir, 'requests'));
-  const requestPath = path.join(requestDir, `${timestampId('request')}.json`);
-  writeJson(requestPath, { ...request, status: 'prepared', requestPath });
-  return { request, requestPath };
-}
-
-export function canSpend(request) {
-  return request.allowSpend === true || process.env.TAKOMI_FLOW_ALLOW_SPEND === 'true';
-}
-
-function toOptionalNumber(value) {
-  if (value === undefined || value === null || value === '') return undefined;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-function normalizeList(value) {
-  if (!value) return [];
-  if (Array.isArray(value)) return value;
-  return String(value).split(',').map(item => item.trim()).filter(Boolean);
-}
+import path from 'node:path';
+import { defaultRunsDir, ensureDir, timestampId, writeJson } from './paths.mjs';
+
+const VALID_KINDS = new Set(['video', 'image']);
+
+export function normalizeRequest(input) {
+  const kind = String(input.kind || 'video').toLowerCase();
+  if (!VALID_KINDS.has(kind)) {
+    throw new Error(`Invalid kind "${kind}". Expected video or image.`);
+  }
+  const prompt = String(input.prompt || '').trim();
+  if (!prompt) {
+    throw new Error('A non-empty prompt is required.');
+  }
+  const variations = Math.max(1, Number.parseInt(input.variations || '1', 10) || 1);
+  return {
+    schemaVersion: 1,
+    kind,
+    prompt,
+    variations,
+    aspectRatio: input.aspectRatio || input['aspect-ratio'] || undefined,
+    durationSeconds: toOptionalNumber(input.durationSeconds || input.duration),
+    mode: input.mode || (kind === 'video' ? 'text-to-video' : 'text-to-image'),
+    modelHint: input.modelHint || input.model || 'best-available',
+    outputDir: path.resolve(input.outputDir || input['output-dir'] || defaultRunsDir()),
+    allowSpend: toOptionalBoolean(input.allowSpend ?? input['allow-spend'], false),
+    extractFrames: Math.max(0, Number.parseInt(input.extractFrames || input['extract-frames'] || '0', 10) || 0),
+    sourceAssets: normalizeList(input.sourceAssets || input.assets),
+    projectUrl: input.projectUrl || input['project-url'] || undefined,
+    reuseCurrentProject: toOptionalBoolean(input.reuseCurrentProject ?? input['reuse-current-project'], true),
+    allowNewProject: toOptionalBoolean(input.allowNewProject ?? input['allow-new-project'], false),
+    freshChatOnFailure: toOptionalBoolean(input.freshChatOnFailure ?? input['fresh-chat-on-failure'], true),
+    editorWaitMs: toOptionalNumber(input.editorWaitMs || input['editor-wait-ms']),
+    notes: input.notes || undefined,
+  };
+}
+
+export function createPreparedRequest(args) {
+  const request = normalizeRequest(args);
+  const requestDir = ensureDir(path.join(request.outputDir, 'requests'));
+  const requestPath = path.join(requestDir, `${timestampId('request')}.json`);
+  writeJson(requestPath, { ...request, status: 'prepared', requestPath });
+  return { request, requestPath };
+}
+
+export function canSpend(request) {
+  return request.allowSpend === true || process.env.TAKOMI_FLOW_ALLOW_SPEND === 'true';
+}
+
+function toOptionalNumber(value) {
+  if (value === undefined || value === null || value === '') return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function toOptionalBoolean(value, defaultValue) {
+  if (value === undefined || value === null || value === '') return defaultValue;
+  if (typeof value === 'boolean') return value;
+  return ['1', 'true', 'yes', 'on'].includes(String(value).toLowerCase());
+}
+
+function normalizeList(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return String(value).split(',').map(item => item.trim()).filter(Boolean);
+}

package/plugins/takomi-flow/scripts/lib/resource-files.mjs

@@ -1,69 +1,69 @@
-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, '..', '..');
-
-export const RESOURCES = [
-  {
-    name: 'takomi-flow-contract',
-    uri: 'takomi-flow://contract',
-    file: path.join(PLUGIN_ROOT, 'references', 'flow-provider-contract.md'),
-    mimeType: 'text/markdown',
-    description: 'TakomiFlow provider contract and agent workflow.',
-  },
-  {
-    name: 'takomi-flow-capabilities',
-    uri: 'takomi-flow://capabilities',
-    file: path.join(PLUGIN_ROOT, 'assets', 'capabilities.json'),
-    mimeType: 'application/json',
-    description: 'Machine-readable TakomiFlow capabilities.',
-  },
-  {
-    name: 'takomi-flow-examples',
-    uri: 'takomi-flow://examples',
-    file: path.join(PLUGIN_ROOT, 'assets', 'examples.json'),
-    mimeType: 'application/json',
-    description: 'Machine-readable TakomiFlow request and handoff examples.',
-  },
-  {
-    name: 'takomi-flow-request-schema',
-    uri: 'takomi-flow://schemas/request',
-    file: path.join(PLUGIN_ROOT, 'assets', 'request.schema.json'),
-    mimeType: 'application/schema+json',
-    description: 'JSON Schema for TakomiFlow request files.',
-  },
-  {
-    name: 'takomi-flow-result-schema',
-    uri: 'takomi-flow://schemas/result',
-    file: path.join(PLUGIN_ROOT, 'assets', 'result.schema.json'),
-    mimeType: 'application/schema+json',
-    description: 'JSON Schema for TakomiFlow run result metadata.',
-  },
-  {
-    name: 'takomi-flow-collection-schema',
-    uri: 'takomi-flow://schemas/collection',
-    file: path.join(PLUGIN_ROOT, 'assets', 'collection.schema.json'),
-    mimeType: 'application/schema+json',
-    description: 'JSON Schema for TakomiFlow collection manifests.',
-  },
-  {
-    name: 'takomi-flow-video-template',
-    uri: 'takomi-flow://templates/video',
-    file: path.join(PLUGIN_ROOT, 'assets', 'templates', 'video-request.json'),
-    mimeType: 'application/json',
-    description: 'Video request template.',
-  },
-  {
-    name: 'takomi-flow-image-template',
-    uri: 'takomi-flow://templates/image',
-    file: path.join(PLUGIN_ROOT, 'assets', 'templates', 'image-request.json'),
-    mimeType: 'application/json',
-    description: 'Image request template.',
-  },
-];
-
-export function readResourceFile(filePath) {
-  return fs.readFileSync(filePath, '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, '..', '..');
+
+export const RESOURCES = [
+  {
+    name: 'takomi-flow-contract',
+    uri: 'takomi-flow://contract',
+    file: path.join(PLUGIN_ROOT, 'references', 'flow-provider-contract.md'),
+    mimeType: 'text/markdown',
+    description: 'TakomiFlow provider contract and agent workflow.',
+  },
+  {
+    name: 'takomi-flow-capabilities',
+    uri: 'takomi-flow://capabilities',
+    file: path.join(PLUGIN_ROOT, 'assets', 'capabilities.json'),
+    mimeType: 'application/json',
+    description: 'Machine-readable TakomiFlow capabilities.',
+  },
+  {
+    name: 'takomi-flow-examples',
+    uri: 'takomi-flow://examples',
+    file: path.join(PLUGIN_ROOT, 'assets', 'examples.json'),
+    mimeType: 'application/json',
+    description: 'Machine-readable TakomiFlow request and handoff examples.',
+  },
+  {
+    name: 'takomi-flow-request-schema',
+    uri: 'takomi-flow://schemas/request',
+    file: path.join(PLUGIN_ROOT, 'assets', 'request.schema.json'),
+    mimeType: 'application/schema+json',
+    description: 'JSON Schema for TakomiFlow request files.',
+  },
+  {
+    name: 'takomi-flow-result-schema',
+    uri: 'takomi-flow://schemas/result',
+    file: path.join(PLUGIN_ROOT, 'assets', 'result.schema.json'),
+    mimeType: 'application/schema+json',
+    description: 'JSON Schema for TakomiFlow run result metadata.',
+  },
+  {
+    name: 'takomi-flow-collection-schema',
+    uri: 'takomi-flow://schemas/collection',
+    file: path.join(PLUGIN_ROOT, 'assets', 'collection.schema.json'),
+    mimeType: 'application/schema+json',
+    description: 'JSON Schema for TakomiFlow collection manifests.',
+  },
+  {
+    name: 'takomi-flow-video-template',
+    uri: 'takomi-flow://templates/video',
+    file: path.join(PLUGIN_ROOT, 'assets', 'templates', 'video-request.json'),
+    mimeType: 'application/json',
+    description: 'Video request template.',
+  },
+  {
+    name: 'takomi-flow-image-template',
+    uri: 'takomi-flow://templates/image',
+    file: path.join(PLUGIN_ROOT, 'assets', 'templates', 'image-request.json'),
+    mimeType: 'application/json',
+    description: 'Image request template.',
+  },
+];
+
+export function readResourceFile(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}

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

@@ -1,31 +1,31 @@
-import path from 'node:path';
-import { ensureDir, timestampId, writeJson } from './paths.mjs';
-
-export function createRun(requestOrArgs, label = 'flow') {
-  const outputDir = path.resolve(requestOrArgs.outputDir || requestOrArgs['output-dir']);
-  const runId = timestampId(label);
-  const runDir = ensureDir(path.join(outputDir, runId));
-  const downloadsDir = ensureDir(path.join(runDir, 'downloads'));
-  const screenshotsDir = ensureDir(path.join(runDir, 'screenshots'));
-  return { runId, runDir, downloadsDir, screenshotsDir };
-}
-
-export function baseResult(status, run, data = {}) {
-  return {
-    schemaVersion: 1,
-    status,
-    runId: run.runId,
-    assets: [],
-    screenshots: [],
-    errors: [],
-    manualActions: [],
-    ...data,
-    metadataPath: path.join(run.runDir, 'run.json'),
-  };
-}
-
-export function saveResult(run, result) {
-  const finalResult = { ...result, metadataPath: path.join(run.runDir, 'run.json') };
-  writeJson(finalResult.metadataPath, finalResult);
-  return finalResult;
-}
+import path from 'node:path';
+import { ensureDir, timestampId, writeJson } from './paths.mjs';
+
+export function createRun(requestOrArgs, label = 'flow') {
+  const outputDir = path.resolve(requestOrArgs.outputDir || requestOrArgs['output-dir']);
+  const runId = timestampId(label);
+  const runDir = ensureDir(path.join(outputDir, runId));
+  const downloadsDir = ensureDir(path.join(runDir, 'downloads'));
+  const screenshotsDir = ensureDir(path.join(runDir, 'screenshots'));
+  return { runId, runDir, downloadsDir, screenshotsDir };
+}
+
+export function baseResult(status, run, data = {}) {
+  return {
+    schemaVersion: 1,
+    status,
+    runId: run.runId,
+    assets: [],
+    screenshots: [],
+    errors: [],
+    manualActions: [],
+    ...data,
+    metadataPath: path.join(run.runDir, 'run.json'),
+  };
+}
+
+export function saveResult(run, result) {
+  const finalResult = { ...result, metadataPath: path.join(run.runDir, 'run.json') };
+  writeJson(finalResult.metadataPath, finalResult);
+  return finalResult;
+}

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

@@ -1,44 +1,44 @@
-import { inspectRun, resolveRun } from './inspect.mjs';
-import { catalogAssets } from './media.mjs';
-import { createReport } from './report.mjs';
-
-export async function reviewRun(args = {}) {
-  if (!args.run) throw new Error('review requires --run <run.json|run-dir>');
-  const summary = inspectRun(args.run);
-  const run = resolveRun(args.run);
-  const catalog = await catalogAssets(run, run.data.assets || [], {
-    frames: args.frames || 0,
-  });
-  const report = createReport({
-    run: args.run,
-    reportPath: args.reportPath,
-  });
-  return {
-    schemaVersion: 1,
-    status: reviewStatus(summary, catalog),
-    runId: summary.runId,
-    runDir: run.runDir,
-    summary,
-    catalog,
-    reportPath: report.reportPath,
-    nextActions: nextActions(summary, catalog),
-  };
-}
-
-function reviewStatus(summary, catalog) {
-  if (summary.errors?.length) return 'attention_required';
-  if (summary.manualActions?.length) return 'manual_action_required';
-  if (catalog.assets?.some(asset => asset.errors?.length || !asset.exists)) return 'attention_required';
-  if (catalog.assets?.length) return 'review_ready';
-  return summary.status || 'unknown';
-}
-
-function nextActions(summary, catalog) {
-  const actions = [];
-  if (summary.errors?.length) actions.push('Review run errors before reusing assets.');
-  if (summary.manualActions?.length) actions.push(...summary.manualActions);
-  if (catalog.assets?.some(asset => asset.frames?.length)) actions.push('Review extracted frames for video quality.');
-  if (catalog.assets?.length) actions.push('Use reportPath for the human handoff.');
-  if (!catalog.assets?.length) actions.push('No assets were cataloged; inspect screenshots and run metadata.');
-  return actions;
-}
+import { inspectRun, resolveRun } from './inspect.mjs';
+import { catalogAssets } from './media.mjs';
+import { createReport } from './report.mjs';
+
+export async function reviewRun(args = {}) {
+  if (!args.run) throw new Error('review requires --run <run.json|run-dir>');
+  const summary = inspectRun(args.run);
+  const run = resolveRun(args.run);
+  const catalog = await catalogAssets(run, run.data.assets || [], {
+    frames: args.frames || 0,
+  });
+  const report = createReport({
+    run: args.run,
+    reportPath: args.reportPath,
+  });
+  return {
+    schemaVersion: 1,
+    status: reviewStatus(summary, catalog),
+    runId: summary.runId,
+    runDir: run.runDir,
+    summary,
+    catalog,
+    reportPath: report.reportPath,
+    nextActions: nextActions(summary, catalog),
+  };
+}
+
+function reviewStatus(summary, catalog) {
+  if (summary.errors?.length) return 'attention_required';
+  if (summary.manualActions?.length) return 'manual_action_required';
+  if (catalog.assets?.some(asset => asset.errors?.length || !asset.exists)) return 'attention_required';
+  if (catalog.assets?.length) return 'review_ready';
+  return summary.status || 'unknown';
+}
+
+function nextActions(summary, catalog) {
+  const actions = [];
+  if (summary.errors?.length) actions.push('Review run errors before reusing assets.');
+  if (summary.manualActions?.length) actions.push(...summary.manualActions);
+  if (catalog.assets?.some(asset => asset.frames?.length)) actions.push('Review extracted frames for video quality.');
+  if (catalog.assets?.length) actions.push('Use reportPath for the human handoff.');
+  if (!catalog.assets?.length) actions.push('No assets were cataloged; inspect screenshots and run metadata.');
+  return actions;
+}