@scenerok/cli 1.0.0 → 1.0.1

package/dist/lib/api.js

@@ -10,18 +10,22 @@ class ApiError extends Error {
         this.name = 'ApiError';
     }
 }
-async function apiCall(method, path, body) {
-    const baseUrl = getBaseUrl();
+function getAuthHeaders(contentType = 'application/json') {
     const token = getApiToken();
-    const headers = {
-        'Content-Type': 'application/json',
-    };
+    const headers = {};
+    if (contentType) {
+        headers['Content-Type'] = contentType;
+    }
     if (token) {
         headers['Authorization'] = `Bearer ${token}`;
     }
+    return headers;
+}
+async function apiCall(method, path, body) {
+    const baseUrl = getBaseUrl();
     const response = await fetch(`${baseUrl}${path}`, {
         method,
-        headers,
+        headers: getAuthHeaders(),
         body: body ? JSON.stringify(body) : undefined,
     });
     const data = await response.json().catch(() => ({}));
@@ -30,15 +34,62 @@ async function apiCall(method, path, body) {
     }
     return data;
 }
+async function apiFormCall(path, formData) {
+    const baseUrl = getBaseUrl();
+    const headers = getAuthHeaders('');
+    const response = await fetch(`${baseUrl}${path}`, {
+        method: 'POST',
+        headers,
+        body: formData,
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+        throw new ApiError(data.error || `HTTP ${response.status}`, response.status, data);
+    }
+    return data;
+}
 export async function validateVidscript(vidscript) {
     return apiCall('POST', '/api/cli/validate', { vidscript });
 }
-export async function submitRender(vidscript, resolution) {
-    return apiCall('POST', '/api/cli/render', { vidscript, resolution });
+export async function submitRender(vidscript, resolution, templateId) {
+    return apiCall('POST', '/api/cli/render', { vidscript, resolution, templateId });
 }
 export async function getRenderStatus(renderId) {
     return apiCall('GET', `/api/cli/status?id=${renderId}`);
 }
+export async function downloadRender(renderId) {
+    const baseUrl = getBaseUrl();
+    const response = await fetch(`${baseUrl}/api/cli/render/download?id=${renderId}`, {
+        method: 'GET',
+        headers: getAuthHeaders(''),
+    });
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new ApiError(data.error || `HTTP ${response.status}`, response.status, data);
+    }
+    const disposition = response.headers.get('content-disposition') || '';
+    const filenameMatch = disposition.match(/filename="([^"]+)"/);
+    const filename = filenameMatch?.[1] || `${renderId}.mp4`;
+    return {
+        buffer: Buffer.from(await response.arrayBuffer()),
+        filename,
+    };
+}
+export async function uploadProject(formData) {
+    return apiFormCall('/api/cli/projects', formData);
+}
+export async function listProjects() {
+    return apiCall('GET', '/api/cli/projects');
+}
+export async function getAssetCache(options = {}) {
+    const params = new URLSearchParams();
+    if (options.plugin)
+        params.set('plugin', options.plugin);
+    if (options.limit)
+        params.set('limit', String(options.limit));
+    const suffix = params.toString() ? `?${params.toString()}` : '';
+    return apiCall('GET', `/api/cli/asset-cache${suffix}`);
+}
 export async function initiateDeviceAuth(deviceName) {
     return apiCall('POST', '/api/cli/auth/device', { deviceName });
 }

package/dist/lib/config.d.ts

@@ -8,4 +8,6 @@ export declare function writeConfig(config: CliConfig): void;
 export declare function getBaseUrl(): string;
 export declare function getApiToken(): string | undefined;
 export declare function isAuthenticated(): boolean;
+export declare function getConfigDir(): string;
+export declare function getCacheDir(): string;
 //# sourceMappingURL=config.d.ts.map

package/dist/lib/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAQD,wBAAgB,UAAU,IAAI,SAAS,CAUtC;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,QAG5C;AAED,wBAAgB,UAAU,IAAI,MAAM,CAGnC;AAED,wBAAgB,WAAW,IAAI,MAAM,GAAG,SAAS,CAGhD;AAED,wBAAgB,eAAe,IAAI,OAAO,CAEzC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAQD,wBAAgB,UAAU,IAAI,SAAS,CAUtC;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,QAG5C;AAED,wBAAgB,UAAU,IAAI,MAAM,CAGnC;AAED,wBAAgB,WAAW,IAAI,MAAM,GAAG,SAAS,CAGhD;AAED,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED,wBAAgB,YAAY,IAAI,MAAM,CAGrC;AAED,wBAAgB,WAAW,IAAI,MAAM,CAKpC"}

package/dist/lib/config.js

@@ -3,6 +3,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 const CONFIG_DIR = join(homedir(), '.scenerok');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+const CACHE_DIR = join(CONFIG_DIR, 'cache');
 function ensureConfigDir() {
     if (!existsSync(CONFIG_DIR)) {
         mkdirSync(CONFIG_DIR, { recursive: true });
@@ -35,3 +36,13 @@ export function getApiToken() {
 export function isAuthenticated() {
     return !!getApiToken();
 }
+export function getConfigDir() {
+    ensureConfigDir();
+    return CONFIG_DIR;
+}
+export function getCacheDir() {
+    if (!existsSync(CACHE_DIR)) {
+        mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    return CACHE_DIR;
+}

package/dist/lib/project.d.ts

@@ -0,0 +1,14 @@
+export interface PreparedProject {
+    rootDir: string;
+    entryFile: string;
+    originalVidscript: string;
+    rewrittenVidscript: string;
+    assets: Array<{
+        localPath: string;
+        absolutePath: string;
+    }>;
+}
+export declare function listAssetFiles(assetDir: string): string[];
+export declare function prepareProject(entryFile: string, assetDirs?: string[]): PreparedProject;
+export declare function appendProjectToForm(formData: FormData, project: PreparedProject): Promise<void>;
+//# sourceMappingURL=project.d.ts.map

package/dist/lib/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/lib/project.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,KAAK,CAAC;QACZ,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;CACJ;AAuBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAoBzD;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,GAAE,MAAM,EAAO,GAAG,eAAe,CAgD3F;AAED,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAcrG"}

package/dist/lib/project.js

@@ -0,0 +1,97 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+const INPUT_RE = /^(\s*input\s+[A-Za-z_][A-Za-z0-9_]*\s*=\s*)(["'])([^"']+)(\2)/gm;
+const HTTP_RE = /^https?:\/\//i;
+function isRenderableLocalPath(value) {
+    return Boolean(value) && !HTTP_RE.test(value) && !value.startsWith('/uploads/') && !value.startsWith('data:');
+}
+function getMimeType(filePath) {
+    const ext = filePath.toLowerCase().split('.').pop();
+    switch (ext) {
+        case 'mp4': return 'video/mp4';
+        case 'mov': return 'video/quicktime';
+        case 'webm': return 'video/webm';
+        case 'mp3': return 'audio/mpeg';
+        case 'wav': return 'audio/wav';
+        case 'png': return 'image/png';
+        case 'jpg':
+        case 'jpeg': return 'image/jpeg';
+        case 'webp': return 'image/webp';
+        case 'gif': return 'image/gif';
+        default: return 'application/octet-stream';
+    }
+}
+export function listAssetFiles(assetDir) {
+    const results = [];
+    function walk(dir) {
+        for (const entry of readdirSync(dir)) {
+            const absolute = join(dir, entry);
+            const stats = statSync(absolute);
+            if (stats.isDirectory()) {
+                walk(absolute);
+            }
+            else if (stats.isFile()) {
+                results.push(absolute);
+            }
+        }
+    }
+    if (existsSync(assetDir)) {
+        walk(assetDir);
+    }
+    return results;
+}
+export function prepareProject(entryFile, assetDirs = []) {
+    const absoluteEntry = resolve(entryFile);
+    if (!existsSync(absoluteEntry)) {
+        throw new Error(`VidScript file not found: ${entryFile}`);
+    }
+    const rootDir = dirname(absoluteEntry);
+    const originalVidscript = readFileSync(absoluteEntry, 'utf-8');
+    const assetsByPath = new Map();
+    let rewrittenVidscript = originalVidscript.replace(INPUT_RE, (match, prefix, quote, rawPath, suffix) => {
+        if (!isRenderableLocalPath(rawPath)) {
+            return match;
+        }
+        const absolutePath = isAbsolute(rawPath) ? rawPath : resolve(rootDir, rawPath);
+        if (!existsSync(absolutePath)) {
+            return match;
+        }
+        const localPath = relative(rootDir, absolutePath).replace(/\\/g, '/');
+        assetsByPath.set(localPath, absolutePath);
+        return `${prefix}${quote}{{asset:${localPath}}}${suffix}`;
+    });
+    for (const dir of assetDirs) {
+        const absoluteDir = resolve(dir);
+        for (const absolutePath of listAssetFiles(absoluteDir)) {
+            const localPath = relative(rootDir, absolutePath).replace(/\\/g, '/');
+            assetsByPath.set(localPath, absolutePath);
+        }
+    }
+    for (const [localPath] of assetsByPath) {
+        const token = `{{asset:${localPath}}}`;
+        rewrittenVidscript = rewrittenVidscript.replaceAll(token, `__SCENEROK_ASSET_${Buffer.from(localPath).toString('base64url')}__`);
+    }
+    return {
+        rootDir,
+        entryFile: basename(absoluteEntry),
+        originalVidscript,
+        rewrittenVidscript,
+        assets: Array.from(assetsByPath.entries()).map(([localPath, absolutePath]) => ({
+            localPath,
+            absolutePath,
+        })),
+    };
+}
+export async function appendProjectToForm(formData, project) {
+    formData.set('localRoot', project.rootDir);
+    formData.set('entryFile', project.entryFile);
+    formData.set('originalVidscript', project.originalVidscript);
+    let serverVidscript = project.rewrittenVidscript;
+    for (const asset of project.assets) {
+        const bytes = readFileSync(asset.absolutePath);
+        const blob = new Blob([new Uint8Array(bytes)], { type: getMimeType(asset.absolutePath) });
+        formData.append('asset', blob, basename(asset.absolutePath));
+        formData.append('assetPath', asset.localPath);
+    }
+    formData.set('vidscript', serverVidscript);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scenerok/cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "SceneRok CLI - Create videos from your terminal and agent workflows",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist",
+    "skills",
     "README.md"
   ],
   "scripts": {

package/skills/aider/SKILL.md

@@ -0,0 +1,171 @@
+# SceneRok Skill for Claude Code
+
+## Overview
+
+You are a VidScript composer and video generation expert integrated with Claude Code. You help users create video content using the SceneRok platform directly from their terminal.
+
+## Capabilities
+
+- Compose VidScript files for video generation
+- Validate VidScript syntax before rendering
+- Submit render jobs to SceneRok
+- Check render status and retrieve output
+- Guide users through video creation workflows
+- Fill template placeholders and customize system templates
+
+## VidScript Language
+
+VidScript is a declarative language for describing video compositions using time blocks, inputs, text overlays, video operations, filters, and compositing.
+
+### Core Concepts
+
+**Inputs** - Declare video sources:
+```vidscript
+input hero = "https://cdn.example.com/hero.mp4"
+input logo = "/uploads/logo.png"
+```
+
+**Time Blocks** - Define what happens during a time range:
+```vidscript
+[-] = hero                               # auto-append: starts after previous block
+hero.Trim(start: 0s, end: 5s)
+
+[- 3s] = text "Hello", style: title, color: "#FFF"   # auto-start, 3s duration
+[0s .. 5s] = hero                                     # explicit range
+[prev + 0.5s .. prev + 2s] = filter "glow"            # expression-based
+```
+
+**Video Operations** - Modify how video plays:
+```vidscript
+hero.Trim(start: 0s, end: 5s)      # trim clip
+hero.Speed(factor: 1.5)             # 50% faster
+hero.Resize(width: 1080, height: 1920)
+hero.Loop(count: 3)                 # play 3 times
+hero.Opacity(value: 0.5, duration: 2s)
+```
+
+**Compositing** - Layer videos:
+```vidscript
+base.Overlay(logo, x: 50, y: 50, opacity: 0.8)
+```
+
+**Filters & Shaders** - Post-processing effects:
+```vidscript
+[0s .. 5s] = filter "vignette", intensity: 0.4
+[2s .. 4s] = filter "sepia", intensity: 0.6
+```
+
+Built-in filters: `monochrome`, `sepia`, `blur`, `chromatic`, `glitch`, `vignette`, `contrast`, `saturation`, `brightness`
+
+**Text Overlays** - Add on-screen text:
+```vidscript
+[0.5s .. 3s] = text "Headline", style: title, position: center, color: "#FFF", size: 72, stroke: "#000", stroke_width: 3
+```
+
+**Output** - Specify render settings:
+```vidscript
+output to "video.mp4", resolution: "1080x1920", fps: 30
+```
+
+### Module System
+
+```vidscript
+export const BRAND_COLOR = "#FF5733"
+export timeline intro(clip: string, headline: string) {
+  [-] = clip                                # auto-append
+  clip.Trim(start: 0s, end: 3s)
+  [- 2s] = text headline, style: title      # auto-start, 2s duration
+}
+```
+
+```vidscript
+import { intro } from "./timelines.vid"
+import * as pack from "./effects.vid"
+import eleven from "@elevenlabs/tts"  # future scoped package      # from npm registry
+import music from "@elevenlabs/music" # generative music
+use intro at [-] with { clip: main, headline: "Welcome" }
+```
+
+### Plugin Calls
+
+```vidscript
+import eleven from "/tts"
+
+[-] = audio eleven.tts("Welcome to SceneRok", voice: "Rachel")
+[-] = video xai.imagine("Cinematic product shot", aspect_ratio: "9:16")
+[-] = audio music("upbeat launch soundtrack", duration: 12, instrumental: true)
+[-] = audio xai.tts("Next line", voice: "eve")
+```
+
+Package-style plugin calls are supported inside time blocks. Use `video ...` for generated visual clips and `audio ...` for generated speech, music, and other generated audio.
+
+### Placeholders
+
+Templates use `{{name | default}}` for user-supplied values:
+```vidscript
+input hero = "{{hero_clip}}"
+[0.5s .. 3s] = text "{{headline | Hello}}", style: title
+```
+
+## Workflow
+
+1. **Understand the goal** — What video does the user want? (promo, testimonial, meme, etc.)
+2. **Plan the structure** — Time blocks, durations, inputs
+3. **Gather assets** — Video URLs or local paths
+4. **Compose VidScript** — Write the full script
+5. **Validate** — Run `scenerok validate script.vid`
+6. **Render** — Run `scenerok render script.vid --watch`
+7. **Deliver** — Share the download URL when complete
+
+## Best Practices
+
+- **Use dynamic timeblocks** — `[-]` auto-advances the cursor, reducing calculation errors
+- **Use `prev` for offsets** — `[prev + 0.5s .. prev + 2s]` for gaps between content
+- **Named arguments for clarity** — `hero.Trim(start: 0s, end: 5s)` over `hero.Trim(0s, 5s)`
+- Use 1080x1920 for vertical content (TikTok/Instagram)
+- Use 1920x1080 for horizontal content (YouTube)
+- Hook viewers in the first 3 seconds
+- Use high-contrast text on video backgrounds with `stroke` and `stroke_width`
+- Include a clear call-to-action
+- Test with `scenerok validate` before rendering
+- Each render costs 1 credit
+
+## CLI Commands
+
+```bash
+scenerok auth login              # Authenticate
+scenerok validate script.vid      # Validate a VidScript
+scenerok render script.vid --watch # Render a video
+scenerok status <render-id>       # Check status
+scenerok skills install <platform> # Install/update agent skill
+scenerok skills list               # List available skills
+scenerok secrets set KEY=VALUE    # Store API key for plugins
+```
+
+## Error Handling
+
+If a render fails:
+1. Check the error message with `scenerok status <id>`
+2. Common issues: missing assets (404 URLs), invalid file paths, syntax errors
+3. Fix the VidScript and re-render
+4. If credits are insufficient, the user needs to purchase more
+
+## Sample Video Types
+
+- **Product Promo** — Hero clip + headline + description + CTA + vignette filter
+- **Social Media Hook** — Fast cuts, bold text, speed adjustments
+- **Testimonial** — Speaker clip + quote text + sepia filter
+- **Meme Remix** — Reaction clip + top/bottom punchline overlays
+- **Title Sequence** — Background clip + glitch shader + bold typography
+
+Always ask clarifying questions about:
+- Target platform (TikTok, Instagram, YouTube, etc.)
+- Brand colors and fonts
+- Existing assets (video clips, logo, etc.)
+- Desired duration and style
+- Whether they want to start from a template or from scratch
+
+## Full Reference
+
+For exhaustive grammar documentation, visit:
+https://scenerok.com/docs/vidscript