veogent 1.0.22 → 1.1.0

package/README.md

@@ -69,8 +69,13 @@ veogent create-project -n "Cyberpunk T-Rex" -k "T-rex, Neon, Sci-fi" -d "A massi
 # Get all chapters within a project ID
 veogent chapters <projectId>
 
-# View characters cast for the project
+# View characters cast for the project (includes readiness info)
 veogent characters <projectId>
+# Response includes: { characters: [{id, name, imageUri, ready}], characterReadiness: {total, ready, allReady} }
+
+# Check scene materialization status (how many scenes are ready)
+veogent scene-materialization-status -p <projectId> -c <chapterId>
+# Response: { expectedScenes, materializedScenes, status: "PROCESSING"|"READY"|"EMPTY" }
 
 # Create scenes automatically using AI-generated narrative scripts
 veogent create-scene -p <projectId> -c <chapterId> --flowkey -C "The T-Rex looks up at the sky." "A meteor shower begins."
@@ -91,8 +96,12 @@ Queue generation jobs directly from the terminal.
 *Note: VEOGENT uses strict validation depending on the request type.*
 
 ```bash
+# List supported models
+veogent image-models   # → { models: ["imagen3.5"] }
+veogent video-models   # → { models: ["veo_3_1_fast", "veo_3_1_fast_r2v"] }
+
 # Generate Image (Supports: imagen3.5)
-veogent request -t "GENERATE_IMAGES" -p <proj> -c <chap> -s <scene> -i "imagen4"
+veogent request -t "GENERATE_IMAGES" -p <proj> -c <chap> -s <scene> -i "imagen3.5"
 
 # Generate Video (Supports: veo_3_1_fast, veo_3_1_fast_r2v)
 # Default/recommended model: veo_3_1_fast
@@ -105,6 +114,43 @@ veogent request -t "VIDEO_UPSCALE" -p <proj> -c <chap> -s <scene> -o "HORIZONTAL
 veogent upscale -p <proj> -c <chap> -s <scene> -o "VERTICAL" -r "VIDEO_RESOLUTION_4K"
 ```
 
+### 📊 Monitoring & Status
+```bash
+# View all requests (most recent first)
+veogent requests
+
+# Get N most recent requests
+veogent requests -n 10
+
+# Filter by project / chapter / status
+veogent requests -p <projectId> -c <chapterId> -n 5
+veogent requests -s FAILED -n 20
+veogent requests -s COMPLETED -p <projectId>
+
+# Scene-level status with embedded asset URLs (image + video)
+veogent scene-status -p <projectId> -c <chapterId>
+# Each scene returns: { sceneId, image: { status, url }, video: { status, url } }
+
+# Full workflow snapshot (scenes + requests + assets)
+veogent workflow-status -p <projectId> -c <chapterId>
+
+# Wait for all images to finish processing
+veogent wait-images -p <projectId> -c <chapterId>
+
+# Wait and verify all images succeeded (not just finished)
+veogent wait-images -p <projectId> -c <chapterId> --require-success
+
+# Same for videos
+veogent wait-videos -p <projectId> -c <chapterId> --require-success
+
+# Queue concurrency status
+veogent queue-status
+
+# Google Flow credit/plan info (requires flow key)
+veogent flow-credits
+veogent flow-credits -f "ya29.a0ATk..."
+```
+
 ---
 
 ## 🤖 For AI Agents
@@ -126,8 +172,9 @@ Veogent CLI ships with a comprehensive **[`skills/SKILL.md`](./skills/SKILL.md)*
 6. Create scenes from returned script list:
    - `veogent create-scene -p <projectId> -c <chapterId> -C "scene 1" "scene 2" ... --flowkey`
 7. Wait for character generation completion (`imageUri` required for all characters):
-   - `veogent characters <projectId>`
-   - If missing/fail: inspect `veogent requests`, recover via `veogent edit-character`.
+   - `veogent characters <projectId>` — check `characterReadiness.allReady === true`
+   - `veogent scene-materialization-status -p <projectId> -c <chapterId>` — verify `status: "READY"`
+   - If missing/fail: inspect `veogent requests -n 20`, recover via `veogent edit-character`.
 8. Generate scene images:
    - `veogent request -t "GENERATE_IMAGES" ...`
    - If image is reported wrong, decode image to Base64 and send to AI reviewer for evaluation.
@@ -140,6 +187,9 @@ Veogent CLI ships with a comprehensive **[`skills/SKILL.md`](./skills/SKILL.md)*
 > 📖 For the full detailed guide with all commands, options tables, and examples, see **[`skills/SKILL.md`](./skills/SKILL.md)**.
 
 **Important:** `veogent requests` is the primary status board for image/video/edit workflows.
+- Use `-n <N>` to get only the N most recent requests.
+- Use `-s FAILED` / `-s COMPLETED` to filter by status.
+- Use `--require-success` on `wait-images` / `wait-videos` to ensure assets actually exist (not just "finished").
 
 **Concurrency:** maximum **5** requests can be processed simultaneously. If the API reports maximum limit reached, treat it as queue-full (wait/retry), not a hard failure.
 

package/index.js

@@ -6,7 +6,7 @@ import { setConfig, clearConfig, getToken } from './config.js';
 
 const program = new Command();
 
-const IMAGE_MODELS = ['imagen3.5', 'imagen4'];
+const IMAGE_MODELS = ['imagen3.5'];
 const VIDEO_MODELS = ['veo_3_1_fast', 'veo_3_1_fast_r2v'];
 
 function globalOpts() {
@@ -696,7 +696,7 @@ program
     .requiredOption('-c, --chapter <chapter>', 'Chapter ID')
     .requiredOption('-s, --scene <scene>', 'Scene ID')
     .option('-o, --orientation <orientation>', 'Request orientation (HORIZONTAL, VERTICAL)')
-    .option('-i, --imagemodel <imagemodel>', 'Image Model (imagen4, imagen3.5)', 'imagen4')
+    .option('-i, --imagemodel <imagemodel>', 'Image Model (imagen3.5)', 'imagen3.5')
     .option('-v, --videomodel <videomodel>', 'Video Model (veo_3_1_fast, veo_3_1_fast_r2v). Default: veo_3_1_fast', 'veo_3_1_fast')
     .option('-S, --speed <speed>', 'Video Speed (normal, timelapse, slowmotion)', 'normal')
     .option('-E, --endscene <endscene>', 'End Scene ID for continuous video generation')
@@ -744,7 +744,11 @@ program
             }
 
             const data = await api.post('/app/request', payload);
-            const requestResult = unwrapData(data);
+            let requestResult = unwrapData(data);
+            // Ensure requestResult is an object (backend may return boolean/primitive)
+            if (typeof requestResult !== 'object' || requestResult === null) {
+                requestResult = { raw: requestResult };
+            }
             // P2-7: Persist endScene metadata when chained video generation
             if (options.endscene) {
                 requestResult.end_scene_id = options.endscene;
@@ -758,13 +762,45 @@ program
 
 program
     .command('requests')
-    .description('Get all generation requests/jobs status for the current user')
-    .action(async () => {
+    .description('Get generation requests/jobs status for the current user')
+    .option('-n, --limit <n>', 'Return only the N most recent requests', null)
+    .option('-p, --project <projectId>', 'Filter by project ID')
+    .option('-c, --chapter <chapterId>', 'Filter by chapter ID')
+    .option('-s, --status <status>', 'Filter by status (e.g. COMPLETED, FAILED, PROCESSING)')
+    .action(async (options) => {
         try {
             const data = await api.get('/app/requests');
-            console.log(JSON.stringify(unwrapData(data), null, 2));
+            let items = unwrapData(data);
+            items = Array.isArray(items) ? items : (items?.items || []);
+
+            // Filter by project
+            if (options.project) {
+                items = items.filter((r) => r?.projectId === options.project || r?.project_id === options.project);
+            }
+            // Filter by chapter
+            if (options.chapter) {
+                items = items.filter((r) => r?.chapterId === options.chapter || r?.chapter_id === options.chapter);
+            }
+            // Filter by status
+            if (options.status) {
+                const s = options.status.toUpperCase();
+                items = items.filter((r) => String(r?.status || '').toUpperCase() === s);
+            }
+            // Sort by createdAt desc (most recent first)
+            items = items.sort((a, b) => {
+                const ta = a?.createdAt || a?.created_at || 0;
+                const tb = b?.createdAt || b?.created_at || 0;
+                return (Number(tb) || 0) - (Number(ta) || 0);
+            });
+            // Limit to N most recent
+            if (options.limit !== null && options.limit !== undefined) {
+                const n = parseInt(options.limit, 10);
+                if (!isNaN(n) && n > 0) items = items.slice(0, n);
+            }
+
+            emitJson({ status: 'success', total: items.length, data: items });
         } catch (error) {
-            console.log(JSON.stringify({ status: "error", ...formatCliError(error) }));
+            emitJson({ status: 'error', ...formatCliError(error) });
         }
     });
 
@@ -1014,6 +1050,184 @@ program
         }
     });
 
+// --- Standalone Generate (Image / Video from text) ---
+program
+    .command('gen-image')
+    .description('Generate an image from a text prompt (standalone, no project needed). Costs 3 credits. Uses Imagen 3.5.')
+    .requiredOption('-p, --prompt <prompt>', 'Text prompt to generate image from (10-2000 chars)')
+    .option('-n, --negative <negative>', 'Negative prompt — things to avoid')
+    .option('-o, --orientation <orientation>', 'Orientation: HORIZONTAL or VERTICAL', 'HORIZONTAL')
+    .option('-w, --wait', 'Wait for completion (poll until done)', false)
+    .option('-i, --interval <sec>', 'Polling interval in seconds (with --wait)', '5')
+    .option('-t, --timeout <sec>', 'Timeout in seconds (with --wait)', '300')
+    .action(async (options) => {
+        try {
+            const payload = {
+                prompt: options.prompt,
+                orientation: options.orientation.toUpperCase(),
+            };
+            if (options.negative) payload.negativePrompt = options.negative;
+
+            humanLog('🎨 Submitting standalone image generation request...');
+            const data = await api.post('/app/standalone/generate-image', payload);
+            const result = unwrapData(data);
+            const requestId = result?.requestId || result?.request_id;
+
+            if (!requestId) {
+                emitJson({ status: 'error', message: 'No requestId returned', data: result });
+                return;
+            }
+
+            humanLog(`✅ Request created: ${requestId}`);
+
+            if (!options.wait) {
+                emitJson({ status: 'success', requestId, message: 'Request submitted. Use --wait to poll for completion, or check with: veogent standalone-request ' + requestId });
+                return;
+            }
+
+            // Poll for completion
+            const intervalMs = Math.max(1, Number(options.interval || 5)) * 1000;
+            const timeoutMs = Math.max(10, Number(options.timeout || 300)) * 1000;
+            const startedAt = Date.now();
+
+            while (Date.now() - startedAt < timeoutMs) {
+                await new Promise((resolve) => setTimeout(resolve, intervalMs));
+                try {
+                    const statusData = await api.get(`/app/standalone/request/${requestId}`);
+                    const req = unwrapData(statusData);
+                    const status = String(req?.status || '').toUpperCase();
+                    humanLog(`⏳ Status: ${status}`);
+
+                    if (status === 'COMPLETED') {
+                        emitJson({ status: 'success', requestId, imageUri: req?.outputData?.imageUri || null, data: req });
+                        return;
+                    }
+                    if (status === 'FAILED') {
+                        emitJson({ status: 'error', requestId, message: req?.message || 'Generation failed', data: req });
+                        process.exit(1);
+                    }
+                } catch (pollErr) {
+                    humanError(`⚠️ Poll error: ${pollErr.message}`);
+                }
+            }
+
+            emitJson({ status: 'error', code: 'WAIT_TIMEOUT', requestId, message: `Timeout after ${options.timeout}s` });
+            process.exit(1);
+        } catch (error) {
+            emitJson({ status: 'error', ...formatCliError(error) });
+            process.exit(1);
+        }
+    });
+
+program
+    .command('gen-video')
+    .description('Generate a video from a text prompt (standalone, no project needed). Costs 5 credits. Uses Veo 3.1 Fast.')
+    .requiredOption('-p, --prompt <prompt>', 'Text prompt to generate video from (10-2000 chars)')
+    .option('-n, --negative <negative>', 'Negative prompt — things to avoid')
+    .option('-o, --orientation <orientation>', 'Orientation: HORIZONTAL or VERTICAL', 'HORIZONTAL')
+    .option('-r, --reference <imageUri>', 'Reference image URI for image-to-video generation')
+    .option('-w, --wait', 'Wait for completion (poll until done)', false)
+    .option('-i, --interval <sec>', 'Polling interval in seconds (with --wait)', '10')
+    .option('-t, --timeout <sec>', 'Timeout in seconds (with --wait)', '600')
+    .action(async (options) => {
+        try {
+            const payload = {
+                prompt: options.prompt,
+                orientation: options.orientation.toUpperCase(),
+            };
+            if (options.negative) payload.negativePrompt = options.negative;
+            if (options.reference) payload.referenceImageUri = options.reference;
+
+            humanLog('🎬 Submitting standalone video generation request...');
+            const data = await api.post('/app/standalone/generate-video', payload);
+            const result = unwrapData(data);
+            const requestId = result?.requestId || result?.request_id;
+
+            if (!requestId) {
+                emitJson({ status: 'error', message: 'No requestId returned', data: result });
+                return;
+            }
+
+            humanLog(`✅ Request created: ${requestId}`);
+
+            if (!options.wait) {
+                emitJson({ status: 'success', requestId, message: 'Request submitted. Use --wait to poll for completion, or check with: veogent standalone-request ' + requestId });
+                return;
+            }
+
+            // Poll for completion
+            const intervalMs = Math.max(1, Number(options.interval || 10)) * 1000;
+            const timeoutMs = Math.max(30, Number(options.timeout || 600)) * 1000;
+            const startedAt = Date.now();
+
+            while (Date.now() - startedAt < timeoutMs) {
+                await new Promise((resolve) => setTimeout(resolve, intervalMs));
+                try {
+                    const statusData = await api.get(`/app/standalone/request/${requestId}`);
+                    const req = unwrapData(statusData);
+                    const status = String(req?.status || '').toUpperCase();
+                    humanLog(`⏳ Status: ${status}`);
+
+                    if (status === 'COMPLETED') {
+                        emitJson({ status: 'success', requestId, videoUri: req?.outputData?.videoUri || null, data: req });
+                        return;
+                    }
+                    if (status === 'FAILED') {
+                        emitJson({ status: 'error', requestId, message: req?.message || 'Generation failed', data: req });
+                        process.exit(1);
+                    }
+                } catch (pollErr) {
+                    humanError(`⚠️ Poll error: ${pollErr.message}`);
+                }
+            }
+
+            emitJson({ status: 'error', code: 'WAIT_TIMEOUT', requestId, message: `Timeout after ${options.timeout}s` });
+            process.exit(1);
+        } catch (error) {
+            emitJson({ status: 'error', ...formatCliError(error) });
+            process.exit(1);
+        }
+    });
+
+program
+    .command('standalone-requests')
+    .description('List your standalone image/video generation requests')
+    .option('-n, --limit <n>', 'Return only the N most recent', null)
+    .option('-s, --status <status>', 'Filter by status (PENDING, PROCESSING, COMPLETED, FAILED)')
+    .action(async (options) => {
+        try {
+            const data = await api.get('/app/standalone/requests');
+            let items = unwrapData(data);
+            items = Array.isArray(items) ? items : (items?.items || []);
+
+            if (options.status) {
+                const s = options.status.toUpperCase();
+                items = items.filter((r) => String(r?.status || '').toUpperCase() === s);
+            }
+
+            if (options.limit !== null && options.limit !== undefined) {
+                const n = parseInt(options.limit, 10);
+                if (!isNaN(n) && n > 0) items = items.slice(0, n);
+            }
+
+            emitJson({ status: 'success', total: items.length, data: items });
+        } catch (error) {
+            emitJson({ status: 'error', ...formatCliError(error) });
+        }
+    });
+
+program
+    .command('standalone-request <requestId>')
+    .description('Get details of a specific standalone request')
+    .action(async (requestId) => {
+        try {
+            const data = await api.get(`/app/standalone/request/${requestId}`);
+            emitJson({ status: 'success', data: unwrapData(data) });
+        } catch (error) {
+            emitJson({ status: 'error', ...formatCliError(error) });
+        }
+    });
+
 // --- System ---
 program
     .command('skill')
@@ -1070,4 +1284,70 @@ program
         }
     });
 
+// Flow Credits — fetch plan and credit info from Google AI Sandbox using flow key
+program
+    .command('flow-credits')
+    .description('Fetch plan and credit info from Google AI Sandbox using your Flow key (Bearer token)')
+    .option('-f, --flowkey <flowkey>', 'Flow key (ya29. token). If omitted, uses stored flow key from account.')
+    .action(async (options) => {
+        try {
+            // Determine which flow key to use
+            let flowKey = options.flowkey;
+
+            if (!flowKey) {
+                // Try to get from stored account
+                const token = getToken();
+                if (!token) {
+                    emitJson({ status: 'error', code: 'NO_TOKEN', message: 'Not logged in. Run: veogent login' });
+                    process.exit(1);
+                }
+                const accountData = unwrapData(await api.get('/app/flow-key'));
+                flowKey = accountData?.flowKey;
+                if (!flowKey) {
+                    emitJson({ status: 'error', code: 'NO_FLOW_KEY', message: 'No flow key found. Set one with: veogent setup-flow -f <token>' });
+                    process.exit(1);
+                }
+            }
+
+            const response = await fetch('https://aisandbox-pa.googleapis.com/v1/credits', {
+                method: 'GET',
+                headers: {
+                    'accept': '*/*',
+                    'accept-language': 'en-US,en;q=0.9',
+                    'authorization': `Bearer ${flowKey}`,
+                    'content-type': 'application/json',
+                    'origin': 'https://veogent.com',
+                    'referer': 'https://veogent.com/',
+                    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36',
+                    'x-browser-channel': 'stable',
+                    'x-browser-year': '2026',
+                },
+            });
+
+            if (!response.ok) {
+                const errText = await response.text();
+                emitJson({ status: 'error', code: `HTTP_${response.status}`, message: errText || response.statusText });
+                process.exit(1);
+            }
+
+            const data = await response.json();
+
+            // Normalize output
+            const result = {
+                status: 'success',
+                plan: data?.plan || data?.tier || data?.subscriptionTier || null,
+                credits: data?.credits ?? data?.remainingCredits ?? data?.balance ?? null,
+                totalCredits: data?.totalCredits ?? data?.maxCredits ?? null,
+                usedCredits: data?.usedCredits ?? null,
+                resetAt: data?.resetAt ?? data?.renewalDate ?? null,
+                raw: data,
+            };
+
+            emitJson(result);
+        } catch (error) {
+            emitJson({ status: 'error', ...formatCliError(error) });
+            process.exit(1);
+        }
+    });
+
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veogent",
-  "version": "1.0.22",
+  "version": "1.1.0",
   "description": "The official CLI to interact with the VEOGENT API - AI Video and Image generation platform",
   "main": "index.js",
   "bin": {