project-graph-mcp 2.3.2 → 2.4.0

package/vendor/symbiote-node/engine/packs/ai/grok-generate.handler.js

@@ -1,565 +0,0 @@
-/**
- * ai/grok-generate — Image/Video generation via Grok browser automation
- *
- * Uses Chrome extension bridge to automate grok.com for:
- * - Text-to-image generation (via WebSocket injection)
- * - Image editing (reference-based generation)
- * - Image-to-video conversion
- * - Batch processing with worker pool
- *
- * Architecture:
- * - Bridge server (localhost:3333) ↔ Chrome extension (grok-bridge)
- * - SELECTORS: stable DOM selectors (aria-label preferred)
- * - ACTIONS: atomic bridge commands
- * - WORKFLOWS: composed sequences
- *
- * Ported from Mr-Computer/modules/ai-music-video/src/services/grok-*.js
- *
- * @module agi-graph/packs/ai/grok-generate
- */
-
-import { readFile, writeFile, mkdir, rename } from 'fs/promises';
-import { existsSync } from 'fs';
-import path from 'path';
-
-export default {
-  type: 'ai/grok-generate',
-  category: 'ai',
-  icon: 'auto_awesome',
-
-  driver: {
-    description: 'Generate images/videos via Grok browser automation',
-    inputs: [
-      { name: 'prompt', type: 'string' },
-      { name: 'referencePath', type: 'string' },
-    ],
-    outputs: [
-      { name: 'result', type: 'any' },
-      { name: 'error', type: 'string' },
-    ],
-    params: {
-      operation: { type: 'string', default: 'image', description: 'Operation: image | image-edit | video | batch-images | batch-videos | check' },
-      bridgeUrl: { type: 'string', default: 'http://localhost:3333', description: 'Bridge server URL' },
-      outputDir: { type: 'string', default: '/tmp/grok-output', description: 'Output directory' },
-      globalStyle: { type: 'string', default: '', description: 'Global style prefix for prompts' },
-      filename: { type: 'string', default: '', description: 'Output filename (without extension)' },
-      enableUpscale: { type: 'boolean', default: false, description: 'HD upscale for videos' },
-      workerId: { type: 'string', default: '', description: 'Worker ID for multi-tab' },
-      // Batch params
-      segments: { type: 'any', default: null, description: 'Segments for batch operations' },
-      workers: { type: 'int', default: 1, description: 'Parallel workers for batch' },
-      // Image params
-      imagePath: { type: 'string', default: '', description: 'Source image for video gen' },
-      videoPrompt: { type: 'string', default: '', description: 'Camera movement prompt for video' },
-    },
-  },
-
-  lifecycle: {
-    validate: (inputs, params) => {
-      if (params.operation === 'check') return true;
-      if (params.operation === 'image' && !inputs.prompt) return false;
-      if (params.operation === 'image-edit' && (!inputs.prompt || !inputs.referencePath)) return false;
-      if (params.operation === 'video' && !params.imagePath) return false;
-      return true;
-    },
-
-    cacheKey: (inputs, params) => {
-      return `grok:${params.operation}:${params.filename || inputs.prompt?.substring(0, 30) || ''}`;
-    },
-
-    execute: async (inputs, params) => {
-      try {
-        const op = params.operation;
-        const bridge = createBridgeClient(params.bridgeUrl);
-
-        if (op === 'check') {
-          const ok = await bridge.checkHealth();
-          return { result: { healthy: ok }, error: null };
-        }
-
-        if (op === 'image') {
-          const result = await generateImage(bridge, inputs.prompt, params);
-          return { result, error: null };
-        }
-
-        if (op === 'image-edit') {
-          const result = await editImage(bridge, inputs.prompt, inputs.referencePath, params);
-          return { result, error: null };
-        }
-
-        if (op === 'video') {
-          const result = await generateVideo(bridge, params);
-          return { result, error: null };
-        }
-
-        if (op === 'batch-images') {
-          const results = await batchImages(bridge, params);
-          return { result: results, error: null };
-        }
-
-        if (op === 'batch-videos') {
-          const results = await batchVideos(bridge, params);
-          return { result: results, error: null };
-        }
-
-        return { result: null, error: `Unknown operation: ${op}` };
-      } catch (err) {
-        return { result: null, error: err.message };
-      }
-    },
-  },
-};
-
-// --- Bridge Client ---
-
-/**
- * Create bridge client for communication with grok-bridge Chrome extension
- * @param {string} baseUrl
- * @returns {Object}
- */
-function createBridgeClient(baseUrl) {
-  const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-
-  async function sendCommand(action, cmdParams = {}, timeout = 30000, workerId = null) {
-    const payload = { action, params: cmdParams };
-    if (workerId) payload.workerId = workerId;
-
-    const sendRes = await fetch(`${baseUrl}/command`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload),
-      signal: AbortSignal.timeout(10000),
-    });
-
-    if (!sendRes.ok) throw new Error('Failed to send command');
-    const { id } = await sendRes.json();
-
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-      await sleep(500);
-      try {
-        const res = await fetch(`${baseUrl}/result/${id}`, {
-          signal: AbortSignal.timeout(5000),
-        });
-        if (!res.ok) continue;
-        const data = await res.json();
-        if (data.error && data.error !== 'Result not found or not ready') {
-          throw new Error(data.error);
-        }
-        if (data.result !== undefined) return data.result;
-      } catch (e) {
-        if (e.message !== 'Result not found or not ready') {
-          // Connection issue — retry poll
-        }
-      }
-    }
-    throw new Error(`Timeout: ${action}`);
-  }
-
-  return {
-    sendCommand,
-    sleep,
-
-    async checkHealth() {
-      try {
-        const res = await fetch(`${baseUrl}/health`, { signal: AbortSignal.timeout(2000) });
-        return res.ok;
-      } catch {
-        return false;
-      }
-    },
-
-    // Atomic actions
-    async navigate(url, workerId) { return sendCommand('navigate', { url }, 30000, workerId); },
-    async waitFor(selector, timeout = 15000, workerId = null) { return sendCommand('waitForSelector', { selector, timeout }, timeout + 5000, workerId); },
-    async click(selector, workerId) { return sendCommand('click', { selector }, 30000, workerId); },
-    async type(selector, text, workerId) { return sendCommand('type', { selector, text }, 30000, workerId); },
-    async uploadFile(base64, mimeType, filename, workerId) { return sendCommand('uploadFile', { base64, mimeType, filename }, 30000, workerId); },
-    async queryAll(selector, workerId) { return sendCommand('querySelectorAll', { selector }, 30000, workerId); },
-    async getAttribute(selector, attribute, workerId) { return sendCommand('getAttribute', { selector, attribute }, 30000, workerId); },
-    async getPageInfo(workerId) { return sendCommand('getPageInfo', {}, 30000, workerId); },
-    async refresh(workerId) { return sendCommand('refresh', {}, 30000, workerId); },
-
-    // WebSocket-based direct generation
-    async generateImageWS(prompt, options, workerId) { return sendCommand('generateImage', { prompt, options }, 90000, workerId); },
-    async fetchImage(url, workerId) { return sendCommand('fetchImage', { url }, 30000, workerId); },
-    async waitForImageComplete(timeout = 120000, workerId) { return sendCommand('waitForImageComplete', { timeout }, timeout + 5000, workerId); },
-
-    // Zone-based interaction
-    async showZones(layer = 'all', workerId) { return sendCommand('showClickableZones', { layer }, 30000, workerId); },
-    async clickZone(zone, workerId) { return sendCommand('clickZone', { zone }, 30000, workerId); },
-    async hideZones(workerId) { return sendCommand('hideZones', {}, 30000, workerId); },
-  };
-}
-
-// --- Selectors ---
-
-const SEL = {
-  promptEditor: '.tiptap.ProseMirror',
-  editPrompt: '[aria-label="Введите для изменения изображения..."]',
-  videoPrompt: 'textarea[aria-label="Сделать видео"]',
-  imageCard: 'div.group\\/media-post-masonry-card img',
-  firstImage: 'div.group\\/media-post-masonry-card:first-child img',
-  video: 'video',
-  downloadBtn: '[aria-label="Скачать"]',
-  sendBtn: '[aria-label="Отправить"]',
-  preferenceBtn: 'button:has(svg.lucide-thumbs-up)',
-  moderatedContent: 'img[alt="Moderated"], svg.lucide-eye-off',
-  errorToast: '[data-sonner-toast][data-type="error"]',
-  hdButton: 'button .text-\\[10px\\].font-bold',
-};
-
-// --- Workflows ---
-
-/**
- * Navigate to /imagine page (skip if already there)
- * @param {Object} bridge
- * @param {string} workerId
- */
-async function ensureOnImagine(bridge, workerId) {
-  try {
-    const pageInfo = await bridge.getPageInfo(workerId);
-    const url = pageInfo?.url || '';
-
-    if (url.includes('grok.com/imagine') && !url.includes('/imagine/post/')) {
-      try {
-        await bridge.waitFor(SEL.promptEditor, 5000, workerId);
-        return;
-      } catch {
-        await bridge.refresh(workerId);
-        await bridge.sleep(3000);
-      }
-    }
-  } catch { /* not on page */ }
-
-  await bridge.navigate('https://grok.com/imagine', workerId);
-  await bridge.sleep(3000);
-  await bridge.waitFor(SEL.promptEditor, 15000, workerId);
-}
-
-/**
- * Generate image via WebSocket (text-to-image)
- * @param {Object} bridge
- * @param {string} prompt
- * @param {Object} params
- * @returns {Promise<Object>}
- */
-async function generateImage(bridge, prompt, params) {
-  const { outputDir, filename, globalStyle, workerId } = params;
-  const fullPrompt = globalStyle ? `${globalStyle}, ${prompt}` : prompt;
-
-  await mkdir(outputDir, { recursive: true });
-
-  // Generate via WebSocket
-  const wsResult = await bridge.generateImageWS(fullPrompt, {}, workerId || null);
-
-  if (!wsResult?.imageUrl) {
-    throw new Error('No image URL from WebSocket generation');
-  }
-
-  // Download image via bridge (authenticated)
-  const imageData = await bridge.fetchImage(wsResult.imageUrl, workerId || null);
-
-  // Save to file
-  const outputName = filename || `grok-${Date.now()}`;
-  const outputPath = path.join(outputDir, `${outputName}.png`);
-
-  const base64Data = imageData.dataUrl.split(',')[1];
-  await writeFile(outputPath, Buffer.from(base64Data, 'base64'));
-
-  return {
-    imagePath: outputPath,
-    imageUrl: wsResult.imageUrl,
-    prompt: fullPrompt,
-  };
-}
-
-/**
- * Edit image with reference (upload + prompt)
- * @param {Object} bridge
- * @param {string} prompt
- * @param {string} referencePath
- * @param {Object} params
- * @returns {Promise<Object>}
- */
-async function editImage(bridge, prompt, referencePath, params) {
-  const { outputDir, filename, workerId } = params;
-  await mkdir(outputDir, { recursive: true });
-
-  // Navigate to /imagine
-  await ensureOnImagine(bridge, workerId || null);
-
-  // Upload reference image
-  const imageBuffer = await readFile(path.resolve(referencePath));
-  const base64 = imageBuffer.toString('base64');
-  const ext = path.extname(referencePath).toLowerCase();
-  const mimeType = ext === '.png' ? 'image/png' : 'image/jpeg';
-
-  await bridge.uploadFile(base64, mimeType, `image${ext}`, workerId || null);
-  await bridge.sleep(2000);
-
-  // Enter edit prompt
-  await bridge.waitFor(SEL.editPrompt, 15000, workerId || null);
-  await bridge.type(SEL.editPrompt, prompt, workerId || null);
-
-  // Submit
-  await bridge.click(SEL.sendBtn, workerId || null);
-
-  // Wait for result via WebSocket
-  const wsResult = await bridge.waitForImageComplete(120000, workerId || null);
-
-  if (!wsResult?.firstUrl) {
-    throw new Error('No image from edit generation');
-  }
-
-  // Download
-  const imageData = await bridge.fetchImage(wsResult.firstUrl, workerId || null);
-  const outputName = filename || `grok-edit-${Date.now()}`;
-  const outputPath = path.join(outputDir, `${outputName}.png`);
-
-  const base64Data = imageData.dataUrl.split(',')[1];
-  await writeFile(outputPath, Buffer.from(base64Data, 'base64'));
-
-  return { imagePath: outputPath, imageUrl: wsResult.firstUrl };
-}
-
-/**
- * Generate video from image (image-to-video)
- * @param {Object} bridge
- * @param {Object} params
- * @returns {Promise<Object>}
- */
-async function generateVideo(bridge, params) {
-  const { imagePath, videoPrompt, outputDir, filename, enableUpscale, workerId } = params;
-  await mkdir(outputDir, { recursive: true });
-
-  // Navigate to /imagine
-  await ensureOnImagine(bridge, workerId || null);
-
-  // Upload image
-  const imageBuffer = await readFile(path.resolve(imagePath));
-  const base64 = imageBuffer.toString('base64');
-  const ext = path.extname(imagePath).toLowerCase();
-  const mimeType = ext === '.png' ? 'image/png' : 'image/jpeg';
-
-  await bridge.uploadFile(base64, mimeType, `image${ext}`, workerId || null);
-  await bridge.sleep(3000);
-
-  // Enter video prompt
-  if (videoPrompt) {
-    await bridge.waitFor(SEL.videoPrompt, 15000, workerId || null);
-    await bridge.type(SEL.videoPrompt, videoPrompt, workerId || null);
-    await bridge.sleep(500);
-  }
-
-  // Show zones and submit
-  await bridge.showZones('all', workerId || null);
-  await bridge.sleep(500);
-
-  // Find and click submit button (zone-based)
-  await bridge.click(SEL.sendBtn, workerId || null);
-  try { await bridge.hideZones(workerId || null); } catch { /* ignore */ }
-
-  // Wait for video
-  const videoUrl = await waitForVideo(bridge, 90000, workerId || null);
-
-  // Download video
-  const outputName = filename || `grok-video-${Date.now()}`;
-  const outputPath = path.join(outputDir, `${outputName}.mp4`);
-
-  const videoResponse = await fetch(videoUrl);
-  if (!videoResponse.ok) throw new Error(`Failed to download video: ${videoResponse.status}`);
-  const buffer = await videoResponse.arrayBuffer();
-  await writeFile(outputPath, Buffer.from(buffer));
-
-  const result = { videoPath: outputPath, videoUrl };
-
-  // HD upscale if requested
-  if (enableUpscale) {
-    try {
-      await triggerUpscale(bridge, workerId || null);
-      const hdUrl = await waitForHD(bridge, 120000, workerId || null, videoUrl);
-
-      const hdPath = path.join(outputDir, `${outputName}_hd.mp4`);
-      const hdResponse = await fetch(hdUrl);
-      if (hdResponse.ok) {
-        const hdBuffer = await hdResponse.arrayBuffer();
-        await writeFile(hdPath, Buffer.from(hdBuffer));
-        result.hdVideoPath = hdPath;
-        result.hdVideoUrl = hdUrl;
-      }
-    } catch (e) {
-      result.upscaleError = e.message;
-    }
-  }
-
-  return result;
-}
-
-// --- Helper workflows ---
-
-/**
- * Wait for video element with mp4 src
- * @param {Object} bridge
- * @param {number} timeout
- * @param {string} workerId
- * @param {string} prevUrl
- * @returns {Promise<string>}
- */
-async function waitForVideo(bridge, timeout = 90000, workerId = null, prevUrl = null) {
-  const start = Date.now();
-
-  while (Date.now() - start < timeout) {
-    await bridge.sleep(3000);
-
-    // Check rate limit
-    try {
-      const errors = await bridge.queryAll(SEL.errorToast, workerId);
-      if (errors.count > 0) throw new Error('RATE_LIMIT_REACHED');
-    } catch (e) {
-      if (e.message === 'RATE_LIMIT_REACHED') throw e;
-    }
-
-    // Check content moderation
-    try {
-      const moderated = await bridge.queryAll(SEL.moderatedContent, workerId);
-      if (moderated.count > 0) throw new Error('CONTENT_MODERATED');
-    } catch (e) {
-      if (e.message === 'CONTENT_MODERATED') throw e;
-    }
-
-    // Check preference selection (A/B test) — refresh to skip
-    try {
-      const prefs = await bridge.queryAll(SEL.preferenceBtn, workerId);
-      if (prefs.count >= 2) {
-        await bridge.refresh(workerId);
-        await bridge.sleep(3000);
-        continue;
-      }
-    } catch { /* ignore */ }
-
-    // Check for video
-    try {
-      const result = await bridge.getAttribute(SEL.video, 'src', workerId);
-      const videoUrl = result.value;
-      if (videoUrl?.includes('.mp4')) {
-        if (prevUrl && videoUrl === prevUrl) continue;
-        return videoUrl;
-      }
-    } catch { /* not yet */ }
-  }
-
-  throw new Error('Timeout waiting for video');
-}
-
-/**
- * Trigger HD upscale via menu
- * @param {Object} bridge
- * @param {string} workerId
- */
-async function triggerUpscale(bridge, workerId) {
-  await bridge.showZones('all', workerId);
-  await bridge.sleep(500);
-  // Menu button→upscale is zone-dependent, use click by text as fallback
-  try {
-    await bridge.click('[aria-label="Больше опций"]', workerId);
-    await bridge.sleep(1000);
-    // Click 5th menu item (upscale)
-    await bridge.click('[role="menuitem"]:nth-child(5)', workerId);
-  } catch {
-    // Fallback
-    await bridge.sendCommand('clickByText', { text: 'Улучшить' }, 30000, workerId);
-  }
-  try { await bridge.hideZones(workerId); } catch { /* ignore */ }
-}
-
-/**
- * Wait for HD video after upscale
- * @param {Object} bridge
- * @param {number} timeout
- * @param {string} workerId
- * @param {string} sdUrl
- * @returns {Promise<string>}
- */
-async function waitForHD(bridge, timeout = 120000, workerId = null, sdUrl = null) {
-  const start = Date.now();
-
-  while (Date.now() - start < timeout) {
-    await bridge.sleep(3000);
-
-    try {
-      const hdExists = await bridge.waitFor(SEL.hdButton, 5000, workerId).catch(() => null);
-      if (hdExists) {
-        const result = await bridge.getAttribute(SEL.video, 'src', workerId);
-        if (result.value?.includes('.mp4')) return result.value;
-      }
-
-      if (sdUrl) {
-        const result = await bridge.getAttribute(SEL.video, 'src', workerId);
-        if (result.value?.includes('.mp4') && result.value !== sdUrl) return result.value;
-      }
-    } catch { /* not yet */ }
-  }
-
-  throw new Error('Timeout waiting for HD video');
-}
-
-// --- Batch processing ---
-
-/**
- * Batch image generation
- * @param {Object} bridge
- * @param {Object} params
- * @returns {Promise<Object>}
- */
-async function batchImages(bridge, params) {
-  const { segments, outputDir, globalStyle } = params;
-  const results = {};
-  await mkdir(outputDir, { recursive: true });
-
-  for (const seg of segments) {
-    try {
-      const result = await generateImage(bridge, seg.prompt || seg.text, {
-        ...params,
-        filename: seg.promptId || seg.id,
-      });
-      results[seg.promptId || seg.id] = result.imagePath;
-    } catch (e) {
-      console.error(`[GrokBatch] Image failed: ${seg.promptId} - ${e.message}`);
-      results[seg.promptId || seg.id] = null;
-    }
-  }
-
-  return { total: segments.length, success: Object.values(results).filter(Boolean).length, results };
-}
-
-/**
- * Batch video generation
- * @param {Object} bridge
- * @param {Object} params
- * @returns {Promise<Object>}
- */
-async function batchVideos(bridge, params) {
-  const { segments, outputDir } = params;
-  const results = {};
-  await mkdir(outputDir, { recursive: true });
-
-  for (const seg of segments) {
-    if (!seg.imagePath) continue;
-
-    try {
-      const result = await generateVideo(bridge, {
-        ...params,
-        imagePath: seg.imagePath,
-        videoPrompt: seg.videoPrompt || seg.cameraPrompt || '',
-        filename: seg.promptId || seg.id,
-      });
-      results[seg.promptId || seg.id] = result.videoPath;
-    } catch (e) {
-      console.error(`[GrokBatch] Video failed: ${seg.promptId} - ${e.message}`);
-      results[seg.promptId || seg.id] = null;
-    }
-  }
-
-  return { total: segments.length, success: Object.values(results).filter(Boolean).length, results };
-}