sogni-gen 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mauvis Ledford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+<p align="center">
+  <img src="screenshot.jpg" alt="Telegram image render workflow" width="320" />
+</p>
+
+# Image & Video gen for 🦞 Moltbot
+
+🎨 Generate **images and videos** using [Sogni AI](https://sogni.ai)'s decentralized GPU network.
+
+A [Clawdbot](https://github.com/clawdbot/clawdbot) skill for AI image + video generation.
+
+## Installation
+
+### As a Clawdbot Skill
+
+```bash
+# Clone to your skills directory
+git clone https://github.com/mauvis/sogni-gen ~/.clawdbot/skills/sogni-gen
+cd ~/.clawdbot/skills/sogni-gen
+npm install
+```
+
+### Standalone
+
+```bash
+git clone https://github.com/mauvis/sogni-gen
+cd sogni-gen
+npm install
+```
+
+## Setup
+
+1. Create a Sogni account at https://sogni.ai
+2. Create credentials file:
+
+```bash
+mkdir -p ~/.config/sogni
+cat > ~/.config/sogni/credentials << 'EOF'
+SOGNI_USERNAME=your_username
+SOGNI_PASSWORD=your_password
+EOF
+chmod 600 ~/.config/sogni/credentials
+```
+
+## Usage
+
+```bash
+# Generate image, get URL
+node sogni-gen.mjs "a dragon eating tacos"
+
+# Save to file
+node sogni-gen.mjs -o dragon.png "a dragon eating tacos"
+
+# JSON output
+node sogni-gen.mjs --json "a dragon eating tacos"
+
+# Different model
+node sogni-gen.mjs -m flux1-schnell-fp8 "a dragon eating tacos"
+```
+
+## Options
+
+```
+-o, --output <path>   Save image to file
+-m, --model <id>      Model (default: z_image_turbo_bf16)
+-w, --width <px>      Width (default: 512)
+-h, --height <px>     Height (default: 512)
+-n, --count <num>     Number of images (default: 1)
+-t, --timeout <sec>   Timeout (default: 30)
+--json                JSON output
+-q, --quiet           Suppress progress
+```
+
+## Models
+
+| Model | Speed | Notes |
+|-------|-------|-------|
+| `z_image_turbo_bf16` | ~5-10s | Default, general purpose |
+| `flux1-schnell-fp8` | ~3-5s | Fast iterations |
+| `flux2_dev_fp8` | ~2min | High quality |
+| `chroma-v.46-flash_fp8` | ~30s | Balanced |
+
+## With Clawdbot
+
+Once installed, just ask your agent:
+
+> "Draw me a picture of a slothicorn eating a banana"
+
+The agent will generate the image and send it to your chat.
+
+## License
+
+MIT

package/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: sogni-gen
+description: Generate images **and videos** using Sogni AI's decentralized network. Ask the agent to "draw", "generate", "create an image", or "make a video/animate" from a prompt or reference image.
+homepage: https://sogni.ai
+metadata:
+  clawdbot:
+    emoji: "🎨"
+    os: ["darwin", "linux", "win32"]
+    requires:
+      bins: ["node"]
+    install:
+      - id: npm
+        kind: exec
+        command: "cd {{skillDir}} && npm install"
+        label: "Install dependencies"
+---
+
+# Sogni Image & Video Generation
+
+Generate **images and videos** using Sogni AI's decentralized GPU network.
+
+## Setup
+
+1. **Get Sogni credentials** at https://sogni.ai
+2. **Create credentials file:**
+```bash
+mkdir -p ~/.config/sogni
+cat > ~/.config/sogni/credentials << 'EOF'
+SOGNI_USERNAME=your_username
+SOGNI_PASSWORD=your_password
+EOF
+chmod 600 ~/.config/sogni/credentials
+```
+
+3. **Install dependencies:**
+```bash
+cd /path/to/sogni-gen
+npm install
+```
+
+## Usage (Images & Video)
+
+```bash
+# Generate and get URL
+node sogni-gen.mjs "a cat wearing a hat"
+
+# Save to file
+node sogni-gen.mjs -o /tmp/cat.png "a cat wearing a hat"
+
+# JSON output (for scripting)
+node sogni-gen.mjs --json "a cat wearing a hat"
+
+# Quiet mode (suppress progress)
+node sogni-gen.mjs -q -o /tmp/cat.png "a cat wearing a hat"
+```
+
+## Options
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `-o, --output <path>` | Save to file | prints URL |
+| `-m, --model <id>` | Model ID | z_image_turbo_bf16 |
+| `-w, --width <px>` | Width | 512 |
+| `-h, --height <px>` | Height | 512 |
+| `-n, --count <num>` | Number of images | 1 |
+| `-t, --timeout <sec>` | Timeout seconds | 30 (300 for video) |
+| `-s, --seed <num>` | Specific seed | random |
+| `--last-seed` | Reuse seed from last render | - |
+| `-c, --context <path>` | Context image for editing | - |
+| `--last-image` | Use last generated image as context/ref | - |
+| `--video, -v` | Generate video instead of image | - |
+| `--fps <num>` | Frames per second (video) | 16 |
+| `--duration <sec>` | Duration in seconds (video) | 5 |
+| `--ref <path>` | Reference image for video | required for video |
+| `--last` | Show last render info | - |
+| `--json` | JSON output | false |
+| `-q, --quiet` | No progress output | false |
+
+## Image Models
+
+| Model | Speed | Use Case |
+|-------|-------|----------|
+| `z_image_turbo_bf16` | Fast (~5-10s) | General purpose, default |
+| `flux1-schnell-fp8` | Very fast | Quick iterations |
+| `flux2_dev_fp8` | Slow (~2min) | High quality |
+| `chroma-v.46-flash_fp8` | Medium | Balanced |
+| `qwen_image_edit_2511_fp8` | Medium | Image editing with context (up to 3) |
+| `qwen_image_edit_2511_fp8_lightning` | Fast | Quick image editing |
+
+## Video Models
+
+| Model | Speed | Use Case |
+|-------|-------|----------|
+| `wan_v2.2-14b-fp8_i2v_lightx2v` | Fast | Default video generation |
+| `wan_v2.2-14b-fp8_i2v` | Slow | Higher quality video |
+
+## Image Editing with Context
+
+Edit images using reference images (Qwen models support up to 3):
+
+```bash
+# Single context image
+node sogni-gen.mjs -c photo.jpg "make the background a beach"
+
+# Multiple context images (subject + style)
+node sogni-gen.mjs -c subject.jpg -c style.jpg "apply the style to the subject"
+
+# Use last generated image as context
+node sogni-gen.mjs --last-image "make it more vibrant"
+```
+
+When context images are provided without `-m`, defaults to `qwen_image_edit_2511_fp8_lightning`.
+
+## Video Generation
+
+Generate videos from a reference image:
+
+```bash
+# Basic video from image
+node sogni-gen.mjs --video --ref cat.jpg -o cat.mp4 "cat walks around"
+
+# Use last generated image as reference
+node sogni-gen.mjs --last-image --video "gentle camera pan"
+
+# Custom duration and FPS
+node sogni-gen.mjs --video --ref scene.png --duration 10 --fps 24 "zoom out slowly"
+```
+
+## Photo Restoration
+
+Restore damaged vintage photos using Qwen image editing:
+
+```bash
+# Basic restoration
+sogni-gen -c damaged_photo.jpg -o restored.png \
+  "professionally restore this vintage photograph, remove damage and scratches"
+
+# Detailed restoration with preservation hints
+sogni-gen -c old_photo.jpg -o restored.png -w 1024 -h 1280 \
+  "restore this vintage photo, remove peeling, tears and wear marks, \
+  preserve natural features and expression, maintain warm nostalgic color tones"
+```
+
+**Tips for good restorations:**
+- Describe the damage: "peeling", "scratches", "tears", "fading"
+- Specify what to preserve: "natural features", "eye color", "hair", "expression"
+- Mention the era for color tones: "1970s warm tones", "vintage sepia"
+
+**Finding received images (Telegram/etc):**
+```bash
+ls -la ~/.clawdbot/media/inbound/*.jpg | tail -3
+cp ~/.clawdbot/media/inbound/<latest>.jpg /tmp/to_restore.jpg
+```
+
+## Agent Usage
+
+When user asks to generate/draw/create an image:
+
+```bash
+# Generate and save locally
+node {{skillDir}}/sogni-gen.mjs -q -o /tmp/generated.png "user's prompt"
+
+# Edit an existing image
+node {{skillDir}}/sogni-gen.mjs -q -c /path/to/input.jpg -o /tmp/edited.png "make it pop art style"
+
+# Generate video from image
+node {{skillDir}}/sogni-gen.mjs -q --video --ref /path/to/image.png -o /tmp/video.mp4 "camera slowly zooms in"
+
+# Then send via message tool with filePath
+```
+
+## JSON Output
+
+```json
+{
+  "success": true,
+  "prompt": "a cat wearing a hat",
+  "model": "z_image_turbo_bf16", 
+  "width": 512,
+  "height": 512,
+  "urls": ["https://..."],
+  "localPath": "/tmp/cat.png"
+}
+```
+
+## Cost
+
+Uses Spark tokens from your Sogni account. 512x512 images are most cost-efficient.
+
+## Troubleshooting
+
+- **Auth errors**: Check credentials in `~/.config/sogni/credentials`
+- **Timeouts**: Try a faster model or increase `-t` timeout
+- **No workers**: Check https://sogni.ai for network status

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "sogni-gen",
+  "version": "1.0.0",
+  "description": "Sogni AI image generation skill for Clawdbot",
+  "type": "module",
+  "main": "sogni-gen.mjs",
+  "bin": {
+    "sogni-gen": "./sogni-gen.mjs"
+  },
+  "scripts": {
+    "test": "node sogni-gen.mjs --help"
+  },
+  "keywords": [
+    "sogni",
+    "ai",
+    "image-generation",
+    "clawdbot",
+    "skill"
+  ],
+  "author": "Mauvis Ledford",
+  "license": "MIT",
+  "dependencies": {
+    "@sogni-ai/sogni-client-wrapper": "^1.3.2"
+  }
+}

package/sogni-gen.mjs

@@ -0,0 +1,501 @@
+#!/usr/bin/env node
+/**
+ * sogni-gen - Generate images and videos using Sogni AI
+ * Usage: sogni-gen [options] "prompt"
+ */
+
+import { SogniClientWrapper, ClientEvent, supportsContextImages, getMaxContextImages } from '@sogni-ai/sogni-client-wrapper';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+const LAST_RENDER_PATH = join(homedir(), '.config', 'sogni', 'last-render.json');
+
+// Parse arguments
+const args = process.argv.slice(2);
+const options = {
+  prompt: null,
+  output: null,
+  model: null, // Will be set based on type
+  width: 512,
+  height: 512,
+  count: 1,
+  json: false,
+  quiet: false,
+  timeout: 30000,
+  seed: null,
+  lastSeed: false,
+  video: false,
+  fps: 16,
+  duration: 5,
+  refImage: null, // Reference image for video (start frame)
+  refImageEnd: null, // End frame for video interpolation
+  contextImages: [] // Context images for image editing
+};
+
+// Parse CLI args
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === '-o' || arg === '--output') {
+    options.output = args[++i];
+  } else if (arg === '-m' || arg === '--model') {
+    options.model = args[++i];
+  } else if (arg === '-w' || arg === '--width') {
+    options.width = parseInt(args[++i]);
+  } else if (arg === '-h' || arg === '--height') {
+    options.height = parseInt(args[++i]);
+  } else if (arg === '-n' || arg === '--count') {
+    options.count = parseInt(args[++i]);
+  } else if (arg === '-t' || arg === '--timeout') {
+    options.timeout = parseInt(args[++i]) * 1000;
+  } else if (arg === '-s' || arg === '--seed') {
+    options.seed = parseInt(args[++i]);
+  } else if (arg === '--last-seed' || arg === '--reseed') {
+    options.lastSeed = true;
+  } else if (arg === '--video' || arg === '-v') {
+    options.video = true;
+  } else if (arg === '--fps') {
+    options.fps = parseInt(args[++i]);
+  } else if (arg === '--duration') {
+    options.duration = parseInt(args[++i]);
+  } else if (arg === '--ref' || arg === '--reference') {
+    options.refImage = args[++i];
+  } else if (arg === '--ref-end' || arg === '--end') {
+    options.refImageEnd = args[++i];
+  } else if (arg === '-c' || arg === '--context') {
+    options.contextImages.push(args[++i]);
+  } else if (arg === '--last-image') {
+    // Use image from last render as reference/context
+    if (existsSync(LAST_RENDER_PATH)) {
+      const lastRender = JSON.parse(readFileSync(LAST_RENDER_PATH, 'utf8'));
+      let lastImagePath = null;
+      if (lastRender.localPath && existsSync(lastRender.localPath)) {
+        lastImagePath = lastRender.localPath;
+      } else if (lastRender.urls?.[0]) {
+        lastImagePath = lastRender.urls[0];
+      }
+      if (lastImagePath) {
+        // Will be resolved later: video uses refImage, image editing uses contextImages
+        options._lastImagePath = lastImagePath;
+      }
+    }
+  } else if (arg === '--last') {
+    // Show last render info
+    if (existsSync(LAST_RENDER_PATH)) {
+      console.log(readFileSync(LAST_RENDER_PATH, 'utf8'));
+    } else {
+      console.error('No previous render found.');
+    }
+    process.exit(0);
+  } else if (arg === '--json') {
+    options.json = true;
+  } else if (arg === '-q' || arg === '--quiet') {
+    options.quiet = true;
+  } else if (arg === '--help') {
+    console.log(`
+sogni-gen - Generate images and videos using Sogni AI
+
+Usage: sogni-gen [options] "prompt"
+
+Image Options:
+  -o, --output <path>   Save to file (otherwise prints URL)
+  -m, --model <id>      Model (default: z_image_turbo_bf16)
+  -w, --width <px>      Width (default: 512)
+  -h, --height <px>     Height (default: 512)
+  -n, --count <num>     Number of images (default: 1)
+  -s, --seed <num>      Use specific seed
+  --last-seed           Reuse seed from previous render
+  -c, --context <path>  Context image for editing (can use multiple)
+  --last-image          Use last generated image as context
+
+Video Options:
+  --video, -v           Generate video instead of image
+  --fps <num>           Frames per second (default: 16)
+  --duration <sec>      Duration in seconds (default: 5)
+  --ref <path|url>      Reference image for video (start frame)
+  --ref-end <path|url>  End frame for interpolation/morphing
+  --last-image          Use last generated image as reference
+
+General:
+  -t, --timeout <sec>   Timeout in seconds (default: 30, video: 300)
+  --last                Show last render info (JSON)
+  --json                Output JSON with all details
+  -q, --quiet           Suppress progress output
+
+Image Models:
+  z_image_turbo_bf16              Fast, general purpose (default)
+  flux1-schnell-fp8               Very fast
+  flux2_dev_fp8                   High quality (slow)
+  qwen_image_edit_2511_fp8        Image editing with context (up to 3 images)
+  qwen_image_edit_2511_fp8_lightning  Fast image editing
+
+Video Models:
+  wan_v2.2-14b-fp8_i2v_lightx2v   Fast (default)
+  wan_v2.2-14b-fp8_i2v            Higher quality
+
+Examples:
+  sogni-gen "a cat wearing a hat"
+  sogni-gen -o cat.jpg "a cat" 
+  sogni-gen --video --ref cat.jpg -o cat.mp4 "cat walks around"
+  sogni-gen --video --last-image "gentle camera pan"
+  sogni-gen -c photo.jpg "make the background a beach" -m qwen_image_edit_2511_fp8
+  sogni-gen -c subject.jpg -c style.jpg "apply the style to the subject"
+`);
+    process.exit(0);
+  } else if (!arg.startsWith('-') && !options.prompt) {
+    options.prompt = arg;
+  }
+}
+
+// Resolve --last-image: video uses refImage, image uses contextImages
+if (options._lastImagePath) {
+  if (options.video) {
+    options.refImage = options._lastImagePath;
+  } else {
+    options.contextImages.push(options._lastImagePath);
+  }
+  delete options._lastImagePath;
+}
+
+// Set defaults based on type and context
+if (options.video) {
+  options.model = options.model || 'wan_v2.2-14b-fp8_i2v_lightx2v';
+  options.timeout = options.timeout === 30000 ? 300000 : options.timeout; // 5 min for video
+} else if (options.contextImages.length > 0) {
+  // Use qwen edit model when context images provided (unless model explicitly set)
+  options.model = options.model || 'qwen_image_edit_2511_fp8_lightning';
+  options.timeout = options.timeout === 30000 ? 60000 : options.timeout; // 1 min for editing
+} else {
+  options.model = options.model || 'z_image_turbo_bf16';
+}
+
+if (!options.prompt) {
+  console.error('Error: No prompt provided. Use --help for usage.');
+  process.exit(1);
+}
+
+if (options.video && !options.refImage) {
+  console.error('Error: Video generation requires a reference image (--ref or --last-image)');
+  process.exit(1);
+}
+
+// Validate context images against model limits
+if (options.contextImages.length > 0 && !options.video) {
+  const maxImages = getMaxContextImages(options.model);
+  if (maxImages === 0) {
+    console.error(`Error: Model ${options.model} does not support context images.`);
+    console.error('Try: qwen_image_edit_2511_fp8 or qwen_image_edit_2511_fp8_lightning');
+    process.exit(1);
+  }
+  if (options.contextImages.length > maxImages) {
+    console.error(`Error: Model ${options.model} supports max ${maxImages} context images, got ${options.contextImages.length}`);
+    process.exit(1);
+  }
+}
+
+// Load last render seed if requested
+if (options.lastSeed) {
+  if (existsSync(LAST_RENDER_PATH)) {
+    try {
+      const lastRender = JSON.parse(readFileSync(LAST_RENDER_PATH, 'utf8'));
+      if (lastRender.seed) {
+        options.seed = lastRender.seed;
+        if (!options.quiet) console.error(`Using seed from last render: ${options.seed}`);
+      }
+    } catch (e) {
+      console.error('Warning: Could not load last render seed');
+    }
+  } else {
+    console.error('Warning: No previous render found, using random seed');
+  }
+}
+
+// Load credentials
+function loadCredentials() {
+  const credPath = join(homedir(), '.config', 'sogni', 'credentials');
+  
+  if (existsSync(credPath)) {
+    const content = readFileSync(credPath, 'utf8');
+    const creds = {};
+    for (const line of content.split('\n')) {
+      const [key, val] = line.split('=');
+      if (key && val) creds[key.trim()] = val.trim();
+    }
+    if (creds.SOGNI_USERNAME && creds.SOGNI_PASSWORD) {
+      return creds;
+    }
+  }
+  
+  if (process.env.SOGNI_USERNAME && process.env.SOGNI_PASSWORD) {
+    return {
+      SOGNI_USERNAME: process.env.SOGNI_USERNAME,
+      SOGNI_PASSWORD: process.env.SOGNI_PASSWORD
+    };
+  }
+  
+  console.error('Error: No Sogni credentials found.');
+  console.error('Create ~/.config/sogni/credentials with:');
+  console.error('  SOGNI_USERNAME=your_username');
+  console.error('  SOGNI_PASSWORD=your_password');
+  process.exit(1);
+}
+
+// Save last render info
+function saveLastRender(info) {
+  try {
+    const dir = dirname(LAST_RENDER_PATH);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(LAST_RENDER_PATH, JSON.stringify(info, null, 2));
+  } catch (e) {
+    // Ignore save errors
+  }
+}
+
+// Fetch image as buffer
+async function fetchImageBuffer(pathOrUrl) {
+  if (pathOrUrl.startsWith('http://') || pathOrUrl.startsWith('https://')) {
+    const response = await fetch(pathOrUrl);
+    return Buffer.from(await response.arrayBuffer());
+  } else {
+    return readFileSync(pathOrUrl);
+  }
+}
+
+async function main() {
+  const creds = loadCredentials();
+  const log = options.quiet ? () => {} : console.error.bind(console);
+  
+  log('Connecting to Sogni...');
+  
+  const client = new SogniClientWrapper({
+    username: creds.SOGNI_USERNAME,
+    password: creds.SOGNI_PASSWORD,
+    network: 'fast',
+    autoConnect: false,
+    authType: 'token'
+  });
+  
+  try {
+    await client.connect();
+    log('Connected.');
+    
+    const results = [];
+    let completedJobs = 0;
+    
+    const completionPromise = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Timeout after ${options.timeout / 1000}s`));
+      }, options.timeout);
+      
+      client.on(ClientEvent.JOB_COMPLETED, (data) => {
+        const jobData = data.job?.data || {};
+        results.push({
+          imageUrl: data.imageUrl,
+          videoUrl: data.videoUrl,
+          seed: jobData.seed,
+          jobIndex: data.jobIndex,
+          projectId: data.projectId
+        });
+        completedJobs++;
+        log(`${options.video ? 'Video' : 'Image'} ${completedJobs}/${options.count} completed`);
+        
+        if (completedJobs >= options.count) {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+      
+      client.on(ClientEvent.JOB_FAILED, (data) => {
+        clearTimeout(timeout);
+        reject(new Error(data.error || 'Job failed'));
+      });
+      
+      // Progress for video
+      if (options.video) {
+        client.on(ClientEvent.PROJECT_PROGRESS, (data) => {
+          if (data.percentage && data.percentage > 0) {
+            log(`Progress: ${Math.round(data.percentage)}%`);
+          }
+        });
+      }
+    });
+    
+    if (options.video) {
+      // Video generation
+      log(`Generating video with ${options.model}...`);
+      log(`Reference: ${options.refImage}`);
+      if (options.refImageEnd) log(`End frame: ${options.refImageEnd}`);
+      
+      const imageBuffer = await fetchImageBuffer(options.refImage);
+      const endImageBuffer = options.refImageEnd ? await fetchImageBuffer(options.refImageEnd) : undefined;
+      const frames = options.fps * options.duration;
+      
+      const projectConfig = {
+        type: 'video',
+        modelId: options.model,
+        positivePrompt: options.prompt,
+        negativePrompt: '',
+        stylePrompt: '',
+        numberOfMedia: options.count,
+        referenceImage: imageBuffer,
+        frames: frames,
+        fps: options.fps,
+        width: options.width,
+        height: options.height,
+        tokenType: 'spark',
+        waitForCompletion: false
+      };
+      
+      // Add end frame for interpolation if provided
+      if (endImageBuffer) {
+        projectConfig.referenceImageEnd = endImageBuffer;
+      }
+      
+      await client.createProject(projectConfig);
+    } else if (options.contextImages.length > 0) {
+      // Image editing with context images
+      log(`Editing with ${options.model}...`);
+      log(`Context images: ${options.contextImages.length}`);
+      if (options.seed) log(`Using seed: ${options.seed}`);
+      
+      // Load all context images as buffers
+      const contextBuffers = await Promise.all(
+        options.contextImages.map(img => fetchImageBuffer(img))
+      );
+      
+      const editConfig = {
+        modelId: options.model,
+        positivePrompt: options.prompt,
+        contextImages: contextBuffers,
+        numberOfMedia: options.count,
+        width: options.width,
+        height: options.height,
+        steps: options.model.includes('lightning') ? 4 : 20,
+        guidance: options.model.includes('lightning') ? 3.5 : 7.5
+      };
+      
+      if (options.seed) {
+        editConfig.seed = options.seed;
+      }
+      
+      await client.createImageEditProject(editConfig);
+    } else {
+      // Standard image generation
+      log(`Generating with ${options.model}...`);
+      if (options.seed) log(`Using seed: ${options.seed}`);
+      
+      const projectConfig = {
+        type: 'image',
+        modelId: options.model,
+        positivePrompt: options.prompt,
+        negativePrompt: '',
+        stylePrompt: '',
+        numberOfImages: options.count,
+        tokenType: 'spark',
+        waitForCompletion: false,
+        sizePreset: 'custom',
+        width: options.width,
+        height: options.height,
+        guidance: 1.0
+      };
+      
+      if (options.seed) {
+        projectConfig.seed = options.seed;
+      }
+      
+      await client.createProject(projectConfig);
+    }
+    
+    // Wait for completion via events
+    await completionPromise;
+    
+    if (results.length > 0) {
+      const urls = results.map(r => options.video ? r.videoUrl : r.imageUrl).filter(Boolean);
+      const firstResult = results[0];
+      
+      // Save last render info
+      const renderInfo = {
+        timestamp: new Date().toISOString(),
+        type: options.video ? 'video' : 'image',
+        prompt: options.prompt,
+        model: options.model,
+        width: options.width,
+        height: options.height,
+        seed: firstResult.seed,
+        seeds: results.map(r => r.seed),
+        projectId: firstResult.projectId,
+        urls: urls,
+        localPath: options.output || null
+      };
+      if (options.video) {
+        renderInfo.fps = options.fps;
+        renderInfo.duration = options.duration;
+        renderInfo.refImage = options.refImage;
+      }
+      if (options.contextImages.length > 0) {
+        renderInfo.contextImages = options.contextImages;
+      }
+      saveLastRender(renderInfo);
+      
+      // Save to file if requested
+      if (options.output && urls[0]) {
+        const response = await fetch(urls[0]);
+        const buffer = Buffer.from(await response.arrayBuffer());
+        
+        const dir = dirname(options.output);
+        if (dir && dir !== '.' && !existsSync(dir)) mkdirSync(dir, { recursive: true });
+        
+        writeFileSync(options.output, buffer);
+        log(`Saved to ${options.output}`);
+      }
+      
+      // Output result
+      if (options.json) {
+        const output = {
+          success: true,
+          type: options.video ? 'video' : 'image',
+          prompt: options.prompt,
+          model: options.model,
+          width: options.width,
+          height: options.height,
+          seed: firstResult.seed,
+          seeds: results.map(r => r.seed),
+          urls: urls,
+          localPath: options.output || null
+        };
+        if (options.video) {
+          output.fps = options.fps;
+          output.duration = options.duration;
+        }
+        if (options.contextImages.length > 0) {
+          output.contextImages = options.contextImages;
+        }
+        console.log(JSON.stringify(output));
+      } else {
+        urls.forEach(url => console.log(url));
+      }
+    } else {
+      throw new Error('No output generated - may have been filtered');
+    }
+    
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: false,
+        error: error.message,
+        prompt: options.prompt
+      }));
+    } else {
+      console.error(`Error: ${error.message}`);
+    }
+    process.exit(1);
+    
+  } finally {
+    try {
+      if (client.isConnected?.()) await client.disconnect();
+    } catch (e) {}
+    process.exit(0);
+  }
+}
+
+main();