@scenerok/cli 2.2.0

package/dist/commands/project.js

@@ -0,0 +1,173 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { downloadRender, getRenderStatus, listProjects, submitRender, uploadProject } from '../lib/api.js';
+import { isAuthenticated } from '../lib/config.js';
+import { appendProjectToForm, prepareProject } from '../lib/project.js';
+function formatDuration(ms) {
+    const totalSeconds = Math.max(0, Math.round(ms / 1000));
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes === 0)
+        return `${seconds}s`;
+    return `${minutes}m ${seconds.toString().padStart(2, '0')}s`;
+}
+async function waitForRender(renderId) {
+    while (true) {
+        await new Promise((resolveWait) => setTimeout(resolveWait, 3000));
+        const status = await getRenderStatus(renderId);
+        if (status.status === 'completed')
+            return status;
+        if (status.status === 'failed') {
+            throw new Error(status.error || 'Render failed');
+        }
+        process.stdout.write(`\r  ${status.status}... ${status.progress}%`);
+    }
+}
+async function downloadRenderTo(renderId, outputDir) {
+    const result = await downloadRender(renderId);
+    mkdirSync(outputDir, { recursive: true });
+    const outputPath = join(outputDir, result.filename);
+    writeFileSync(outputPath, result.buffer);
+    return outputPath;
+}
+export const projectCommand = new Command('project')
+    .description('Upload and render SceneRok projects')
+    .addCommand(new Command('upload')
+    .description('Upload a local VidScript project and its assets')
+    .argument('<file>', 'Path to the project .vidscript file')
+    .option('-t, --title <title>', 'Project title')
+    .option('-d, --description <description>', 'Project description')
+    .option('-a, --assets <dir...>', 'Additional asset directories to upload')
+    .option('--tags <tags>', 'Comma-separated project tags')
+    .option('-r, --render', 'Create a render after uploading')
+    .option('--resolution <resolution>', 'Render resolution if --render is used')
+    .option('-w, --watch', 'Watch the render until complete')
+    .option('--download [dir]', 'Download completed render to a directory', false)
+    .action(async (file, options) => {
+    if (!isAuthenticated()) {
+        console.log(chalk.yellow('Not authenticated'));
+        console.log(chalk.dim('Run: scenerok auth login'));
+        process.exit(1);
+    }
+    const spinner = ora('Preparing project...').start();
+    try {
+        const project = prepareProject(file, options.assets || []);
+        const formData = new FormData();
+        formData.set('title', options.title || project.entryFile.replace(/\.(vid|vidscript)$/i, ''));
+        if (options.description)
+            formData.set('description', options.description);
+        if (options.tags)
+            formData.set('tags', options.tags);
+        if (options.render)
+            formData.set('render', 'true');
+        if (options.resolution)
+            formData.set('resolution', options.resolution);
+        await appendProjectToForm(formData, project);
+        spinner.text = `Uploading project (${project.assets.length} asset${project.assets.length === 1 ? '' : 's'})...`;
+        const result = await uploadProject(formData);
+        spinner.succeed(`Project uploaded (#${result.project.id})`);
+        console.log(chalk.cyan('\nProject\n'));
+        console.log(`  ID:      ${result.project.id}`);
+        console.log(`  Title:   ${result.project.title}`);
+        console.log(`  URL:     ${result.project.projectUrl}`);
+        console.log(`  Assets:  ${result.assets.length}`);
+        if (result.render) {
+            console.log(chalk.cyan('\nRender\n'));
+            console.log(`  ID:       ${result.render.renderId}`);
+            console.log(`  Status:   ${result.render.status}`);
+            console.log(`  URL:      ${result.render.renderUrl}`);
+            console.log(`  Download: ${result.render.downloadUrl}`);
+            if (options.watch || options.download) {
+                console.log(chalk.dim('\nWatching render status...\n'));
+                const status = await waitForRender(result.render.renderId);
+                console.log(chalk.green('\nRender complete'));
+                if (status.clickToDownloadMs !== null) {
+                    console.log(`  Time:     ${formatDuration(status.clickToDownloadMs)}`);
+                }
+            }
+            if (options.download) {
+                const outputDir = typeof options.download === 'string' ? options.download : 'renders';
+                const outputPath = await downloadRenderTo(result.render.renderId, resolve(outputDir));
+                console.log(chalk.green(`Downloaded: ${outputPath}`));
+            }
+        }
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Project upload failed');
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}))
+    .addCommand(new Command('list')
+    .description('List projects uploaded from CLI/agents')
+    .action(async () => {
+    if (!isAuthenticated()) {
+        console.log(chalk.yellow('Not authenticated'));
+        console.log(chalk.dim('Run: scenerok auth login'));
+        process.exit(1);
+    }
+    try {
+        const result = await listProjects();
+        console.log(chalk.cyan('\nProjects\n'));
+        for (const project of result.projects) {
+            console.log(`  #${project.id}  ${project.title}  (${project.status})`);
+        }
+        if (result.projects.length === 0) {
+            console.log(chalk.dim('  No CLI projects yet.'));
+        }
+        console.log('');
+    }
+    catch (error) {
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}))
+    .addCommand(new Command('render')
+    .description('Render an uploaded project')
+    .argument('<project-id>', 'Project ID')
+    .option('-r, --resolution <resolution>', 'Output resolution')
+    .option('-w, --watch', 'Watch render status until complete')
+    .option('--download [dir]', 'Download completed render to a directory', false)
+    .action(async (projectId, options) => {
+    if (!isAuthenticated()) {
+        console.log(chalk.yellow('Not authenticated'));
+        console.log(chalk.dim('Run: scenerok auth login'));
+        process.exit(1);
+    }
+    const id = Number.parseInt(projectId, 10);
+    if (Number.isNaN(id)) {
+        console.log(chalk.red('Invalid project ID'));
+        process.exit(1);
+    }
+    try {
+        const projects = await listProjects();
+        const project = projects.projects.find((item) => item.id === id);
+        if (!project) {
+            throw new Error(`Project not found: ${id}`);
+        }
+        const result = await submitRender('', options.resolution, id);
+        console.log(chalk.green(`Render submitted (#${result.renderId})`));
+        console.log(`  URL:      ${result.renderUrl}`);
+        console.log(`  Download: ${result.downloadUrl}`);
+        if (options.watch || options.download) {
+            const status = await waitForRender(result.renderId);
+            console.log(chalk.green('\nRender complete'));
+            if (status.clickToDownloadMs !== null) {
+                console.log(`  Time:     ${formatDuration(status.clickToDownloadMs)}`);
+            }
+        }
+        if (options.download) {
+            const outputDir = typeof options.download === 'string' ? options.download : 'renders';
+            const outputPath = await downloadRenderTo(result.renderId, resolve(outputDir));
+            console.log(chalk.green(`Downloaded: ${outputPath}`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}));

package/dist/commands/render.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+export declare const statusCommand: Command;
+export declare const renderCommand: Command;
+//# sourceMappingURL=render.d.ts.map

package/dist/commands/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/commands/render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuFpC,eAAO,MAAM,aAAa,SAAwB,CAAC;AAEnD,eAAO,MAAM,aAAa,SAmLtB,CAAC"}

package/dist/commands/render.js

@@ -0,0 +1,242 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { submitRender, getRenderStatus, downloadRender, uploadCliAssets } from '../lib/api.js';
+import { isAuthenticated } from '../lib/config.js';
+import { LINT_COST_CHOICES, runVideoLint } from './lint-video.js';
+import { prepareProject, getMimeType, rewritePreparedVidscriptWithAssetUrls, writeAssetManifest, } from '../lib/project.js';
+import { detectAuthoringLanguage } from '../lib/language.js';
+import { buildSdkSceneModuleMap } from '../lib/sdk-scene-modules.js';
+function formatDuration(ms) {
+    const totalSeconds = Math.max(0, Math.round(ms / 1000));
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes === 0)
+        return `${seconds}s`;
+    return `${minutes}m ${seconds.toString().padStart(2, '0')}s`;
+}
+function createStatusCommand() {
+    return new Command('status')
+        .description('Check render status')
+        .argument('<id>', 'Render job ID')
+        .option('--download [dir]', 'Download completed render to a directory', false)
+        .action(async (id, options) => {
+        if (!isAuthenticated()) {
+            console.log(chalk.yellow('⚠️  Not authenticated'));
+            console.log(chalk.dim('Run: scenerok auth login'));
+            process.exit(1);
+        }
+        const renderId = Number.parseInt(id, 10);
+        if (Number.isNaN(renderId)) {
+            console.log(chalk.red('❌ Invalid render ID'));
+            process.exit(1);
+        }
+        try {
+            const status = await getRenderStatus(renderId);
+            console.log(chalk.cyan('\\n📹 Render Status\\n'));
+            console.log(`  ID:       ${status.id}`);
+            console.log(`  Status:   ${status.status}`);
+            console.log(`  Progress: ${status.progress}%`);
+            if (status.clickToDownloadMs !== null) {
+                console.log(`  Time:     ${formatDuration(status.clickToDownloadMs)}`);
+            }
+            if (status.outputUrl) {
+                console.log(`  Output:   ${status.outputUrl}`);
+            }
+            if (status.downloadUrl) {
+                console.log(`  Download: ${status.downloadUrl}`);
+            }
+            if (options.download) {
+                if (status.status !== 'completed') {
+                    throw new Error('Render is not completed yet');
+                }
+                const outputDir = typeof options.download === 'string' ? options.download : 'renders';
+                const downloaded = await downloadRender(renderId);
+                mkdirSync(resolve(outputDir), { recursive: true });
+                const outputPath = join(resolve(outputDir), downloaded.filename);
+                writeFileSync(outputPath, downloaded.buffer);
+                console.log(`  Saved:    ${outputPath}`);
+            }
+            if (status.error) {
+                console.log(chalk.red(`  Error:    ${status.error}`));
+            }
+            console.log('');
+        }
+        catch (error) {
+            console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+            process.exit(1);
+        }
+    });
+}
+export const statusCommand = createStatusCommand();
+export const renderCommand = new Command('render')
+    .description('Submit a VidScript (.vid) or @scenerok/sdk (.ts/.js) file for rendering')
+    .argument('<file>', 'Path to .vid, .vidscript, .ts, or .js file')
+    .option('-r, --resolution <resolution>', 'Output resolution (e.g. 1080x1920)')
+    .option('-p, --project-id <id>', 'Attach render to an uploaded project ID')
+    .option('-w, --watch', 'Watch render status until complete')
+    .option('--download [dir]', 'Download completed render to a directory', false)
+    .option('--validate [cost]', `After rendering, validate the output MP4 with ffprobe + LLM frame review (billed). Cost tier: ${LINT_COST_CHOICES.join(', ')} (default medium). Implies --watch.`, false)
+    .option('--validation-budget <usd>', 'Hard USD cap on the MP4 LLM review when using --validate')
+    .action(async (file, options) => {
+    if (!isAuthenticated()) {
+        console.log(chalk.yellow('⚠️  Not authenticated'));
+        console.log(chalk.dim('Run: scenerok auth login'));
+        process.exit(1);
+    }
+    const language = detectAuthoringLanguage(file);
+    let vidscript;
+    let preparedProject = null;
+    if (language !== 'vidscript') {
+        try {
+            vidscript = readFileSync(file, 'utf-8');
+        }
+        catch {
+            console.log(chalk.red(`❌ Could not read file: ${file}`));
+            process.exit(1);
+        }
+    }
+    else {
+        try {
+            preparedProject = prepareProject(file);
+            vidscript = preparedProject.rewrittenVidscript;
+        }
+        catch {
+            try {
+                vidscript = readFileSync(file, 'utf-8');
+            }
+            catch {
+                console.log(chalk.red(`❌ Could not read file: ${file}`));
+                process.exit(1);
+            }
+        }
+    }
+    if (preparedProject && preparedProject.assets.length > 0) {
+        const assetSpinner = ora(`Uploading ${preparedProject.assets.length} local asset${preparedProject.assets.length === 1 ? '' : 's'}...`).start();
+        try {
+            const formData = new FormData();
+            for (const asset of preparedProject.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);
+            }
+            const uploaded = await uploadCliAssets(formData);
+            const mappings = uploaded.assets.map((asset, index) => ({
+                localPath: preparedProject.assets[index].localPath,
+                id: asset.id,
+                url: asset.url,
+                mimeType: asset.mimeType,
+                fileSize: asset.fileSize,
+            }));
+            vidscript = rewritePreparedVidscriptWithAssetUrls(vidscript, mappings);
+            const manifestPath = writeAssetManifest(preparedProject, mappings);
+            assetSpinner.succeed(`Uploaded ${uploaded.assets.length} asset${uploaded.assets.length === 1 ? '' : 's'}`);
+            console.log(chalk.dim(`  Manifest: ${manifestPath}`));
+        }
+        catch (error) {
+            assetSpinner.fail('Asset upload failed');
+            console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+            process.exit(1);
+        }
+    }
+    else if (preparedProject) {
+        vidscript = preparedProject.originalVidscript;
+    }
+    if (vidscript.includes('__SCENEROK_ASSET_')) {
+        console.log(chalk.red('❌ Some local assets could not be uploaded or mapped.'));
+        process.exit(1);
+    }
+    const workingDirectory = preparedProject?.rootDir ?? dirname(resolve(file));
+    const moduleMap = language === 'vidscript'
+        ? buildSdkSceneModuleMap(preparedProject?.originalVidscript ?? vidscript, workingDirectory)
+        : undefined;
+    const moduleOptions = moduleMap && Object.keys(moduleMap).length > 0
+        ? { moduleMap, workingDirectory }
+        : { workingDirectory };
+    const spinner = ora('Submitting render job...').start();
+    try {
+        const projectId = options.projectId ? Number.parseInt(options.projectId, 10) : undefined;
+        if (options.projectId && Number.isNaN(projectId)) {
+            throw new Error('Invalid project ID');
+        }
+        const result = await submitRender(vidscript, options.resolution, projectId, { language, ...moduleOptions });
+        spinner.succeed(`Render job submitted (#${result.renderId})`);
+        console.log(chalk.cyan('\\n📹 Render Job\\n'));
+        console.log(`  ID:         ${result.renderId}`);
+        console.log(`  Status:     ${result.status}`);
+        console.log(`  Resolution: ${result.resolution}`);
+        console.log(`  Output:     ${result.outputFilename}`);
+        console.log(`  Mode:       ${result.dispatchMode}`);
+        console.log(`  Render URL: ${result.renderUrl}`);
+        console.log(`  Download:   ${result.downloadUrl}`);
+        if (result.logUrl) {
+            console.log(`  Log:        ${result.logUrl}`);
+        }
+        console.log('');
+        const validateCost = typeof options.validate === 'string' ? options.validate : options.validate ? 'medium' : undefined;
+        if (validateCost && !LINT_COST_CHOICES.includes(validateCost)) {
+            console.log(chalk.red(`❌ Invalid --validate cost "${validateCost}" — use ${LINT_COST_CHOICES.join(', ')}`));
+            process.exit(1);
+        }
+        let validationBudgetUsd;
+        if (options.validationBudget !== undefined) {
+            validationBudgetUsd = Number.parseFloat(options.validationBudget);
+            if (Number.isNaN(validationBudgetUsd) || validationBudgetUsd <= 0) {
+                console.log(chalk.red('❌ --validation-budget must be a positive USD amount'));
+                process.exit(1);
+            }
+        }
+        if (options.watch || options.download || validateCost) {
+            console.log(chalk.dim('Watching render status...\\n'));
+            while (true) {
+                await new Promise((resolve) => setTimeout(resolve, 3000));
+                const status = await getRenderStatus(result.renderId);
+                if (status.status === 'completed') {
+                    console.log(chalk.green(`\\n✅ Render complete!\\n`));
+                    if (status.clickToDownloadMs !== null) {
+                        console.log(`  Time:     ${formatDuration(status.clickToDownloadMs)}`);
+                    }
+                    console.log(`  Download: ${status.downloadUrl}`);
+                    if (options.download) {
+                        const outputDir = typeof options.download === 'string' ? options.download : 'renders';
+                        const downloaded = await downloadRender(result.renderId);
+                        mkdirSync(resolve(outputDir), { recursive: true });
+                        const outputPath = join(resolve(outputDir), downloaded.filename);
+                        writeFileSync(outputPath, downloaded.buffer);
+                        console.log(`  Saved:    ${outputPath}`);
+                    }
+                    console.log('');
+                    if (validateCost) {
+                        const passed = await runVideoLint(result.renderId, {
+                            cost: validateCost,
+                            budgetUsd: validationBudgetUsd,
+                        });
+                        if (!passed)
+                            process.exit(1);
+                    }
+                    break;
+                }
+                if (status.status === 'failed') {
+                    console.log(chalk.red(`\\n❌ Render failed: ${status.error}\\n`));
+                    process.exit(1);
+                }
+                process.stdout.write(`\r  ${status.status}... ${status.progress}%`);
+            }
+        }
+        else {
+            console.log(chalk.dim(`Check status: scenerok status ${result.renderId}`));
+            console.log(chalk.dim(`Open render:  ${result.renderUrl}`));
+        }
+    }
+    catch (error) {
+        spinner.fail('Render submission failed');
+        if (error instanceof Error) {
+            console.error(chalk.red(error.message));
+        }
+        process.exit(1);
+    }
+});
+renderCommand.addCommand(createStatusCommand());

package/dist/commands/skills.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const skillsCommand: Command;
+//# sourceMappingURL=skills.d.ts.map

package/dist/commands/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../src/commands/skills.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgGpC,eAAO,MAAM,aAAa,SAuKvB,CAAC"}

package/dist/commands/skills.js

@@ -0,0 +1,208 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { existsSync, copyFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { checkSkills, fetchManifest, fetchSkillFile, slugToFilename, } from '../utils/skillsManifest.js';
+function getPlatformConfig(platform) {
+    const configs = {
+        opencode: {
+            name: 'OpenCode',
+            skillDir: join(homedir(), '.agents/skills/scenerok'),
+        },
+        claude: {
+            name: 'Claude Code',
+            skillDir: join(homedir(), '.claude/skills/scenerok'),
+        },
+        codex: {
+            name: 'Codex',
+            skillDir: join(homedir(), '.codex/skills/scenerok'),
+        },
+        cursor: {
+            name: 'Cursor',
+            skillDir: join(homedir(), '.cursor/skills/scenerok'),
+        },
+        aider: {
+            name: 'Aider',
+            skillDir: join(homedir(), '.aider/skills/scenerok'),
+        },
+    };
+    return configs[platform] || null;
+}
+const ROUTER_SKILL = { source: 'skills/shared/SKILL.md', dest: 'SKILL.md' };
+async function findSkillSource(sourcePath) {
+    const modulePath = join(dirname(new URL(import.meta.url).pathname), '../..', sourcePath);
+    if (existsSync(modulePath))
+        return modulePath;
+    const cwdPath = join(process.cwd(), sourcePath);
+    if (existsSync(cwdPath))
+        return cwdPath;
+    try {
+        const { execSync } = await import('node:child_process');
+        const globalRoot = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+        const globalPath = join(globalRoot, '@scenerok', 'cli', sourcePath);
+        if (existsSync(globalPath))
+            return globalPath;
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function printSkillDiff(skills) {
+    for (const s of skills) {
+        const icon = s.status === 'current' ? chalk.green('✓') :
+            s.status === 'outdated' ? chalk.yellow('↻') :
+                chalk.red('✗');
+        console.log(`  ${icon} ${s.filename} (${s.status})`);
+    }
+}
+async function syncSkills(skillDir, slugs) {
+    const manifest = await fetchManifest();
+    const toSync = slugs ?? Object.keys(manifest.skills);
+    let count = 0;
+    for (const slug of toSync.sort()) {
+        const content = await fetchSkillFile(slug);
+        const dest = join(skillDir, slugToFilename(slug));
+        writeFileSync(dest, content, 'utf8');
+        console.log(chalk.green(`  ✓ ${slugToFilename(slug)}`));
+        count++;
+    }
+    return count;
+}
+export const skillsCommand = new Command('skills')
+    .description('Install and sync SceneRok agent skills')
+    .addCommand(new Command('install')
+    .description('Install the router skill for a platform')
+    .argument('<platform>', 'Agent platform: opencode, claude, codex, cursor, aider')
+    .option('--sync', 'Also download the full remote skill bundle')
+    .action(async (platform, opts) => {
+    const config = getPlatformConfig(platform);
+    if (!config) {
+        console.log(chalk.red(`❌ Unknown platform: ${platform}`));
+        console.log(chalk.dim('Supported platforms: opencode, claude, codex, cursor, aider'));
+        process.exit(1);
+    }
+    console.log(chalk.cyan(`\n📦 Installing SceneRok router skill for ${config.name}...\n`));
+    if (!existsSync(config.skillDir)) {
+        mkdirSync(config.skillDir, { recursive: true });
+    }
+    const source = await findSkillSource(ROUTER_SKILL.source);
+    const dest = join(config.skillDir, ROUTER_SKILL.dest);
+    if (!source) {
+        console.log(chalk.red(`  ✗ Router skill not found (${ROUTER_SKILL.source})`));
+        process.exit(1);
+    }
+    copyFileSync(source, dest);
+    console.log(chalk.green(`  ✓ ${ROUTER_SKILL.dest} (router)`));
+    if (opts.sync) {
+        console.log(chalk.cyan('\n⬇️  Syncing remote skill bundle...\n'));
+        await syncSkills(config.skillDir);
+    }
+    console.log(chalk.cyan(`\n✅ Router skill installed to ${config.skillDir}\n`));
+    console.log(chalk.dim('Agents fetch latest docs from https://scenerok.com/.well-known/agent-skills/'));
+    console.log(chalk.dim('Offline fallback: scenerok skills sync'));
+}))
+    .addCommand(new Command('sync')
+    .description('Download the full remote skill bundle locally')
+    .option('--dir <path>', 'Skill directory (auto-detected if omitted)')
+    .option('--platform <platform>', 'Platform to resolve skill dir')
+    .action(async (opts) => {
+    const skillDir = opts.dir ??
+        (opts.platform ? getPlatformConfig(opts.platform)?.skillDir : undefined) ??
+        (await import('../utils/skillsManifest.js')).locateSkillDir();
+    if (!skillDir) {
+        console.log(chalk.red('❌ No skill directory found. Run: scenerok skills install <platform>'));
+        process.exit(1);
+    }
+    if (!existsSync(skillDir))
+        mkdirSync(skillDir, { recursive: true });
+    console.log(chalk.cyan(`\n⬇️  Syncing remote skills to ${skillDir}...\n`));
+    const count = await syncSkills(skillDir);
+    console.log(chalk.cyan(`\n✅ Synced ${count} files\n`));
+}))
+    .addCommand(new Command('check')
+    .description('Check whether local skills match the remote manifest')
+    .option('--json', 'Machine-readable output')
+    .option('--dir <path>', 'Skill directory to check')
+    .action(async (opts) => {
+    try {
+        const result = await checkSkills({ dir: opts.dir });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+            process.exit(result.updateAvailable ? 1 : 0);
+        }
+        console.log(chalk.cyan('\n📋 SceneRok skills check\n'));
+        if (result.location) {
+            console.log(chalk.dim(`Location: ${result.location}\n`));
+        }
+        else {
+            console.log(chalk.yellow('No local install found. Run: scenerok skills install <platform>\n'));
+        }
+        printSkillDiff(result.skills);
+        const { current, outdated, missing } = result.summary;
+        console.log('');
+        console.log(chalk.dim(`${current} current · ${outdated} outdated · ${missing} missing`));
+        if (result.updateAvailable) {
+            console.log(chalk.yellow('\nUpdate available: scenerok skills update\n'));
+            process.exit(1);
+        }
+        console.log(chalk.green('\n✅ Skills are up to date\n'));
+    }
+    catch (err) {
+        console.log(chalk.red(`❌ ${err.message}`));
+        process.exit(1);
+    }
+}))
+    .addCommand(new Command('update')
+    .description('Refresh outdated or missing local skill files')
+    .option('--dir <path>', 'Skill directory')
+    .action(async (opts) => {
+    const { locateSkillDir } = await import('../utils/skillsManifest.js');
+    const skillDir = opts.dir ?? locateSkillDir();
+    if (!skillDir) {
+        console.log(chalk.red('❌ No skill directory found. Run: scenerok skills install <platform>'));
+        process.exit(1);
+    }
+    const result = await checkSkills({ dir: skillDir });
+    const toUpdate = result.skills
+        .filter((s) => s.status !== 'current')
+        .map((s) => s.name);
+    if (toUpdate.length === 0) {
+        console.log(chalk.green('\n✅ Skills already up to date\n'));
+        return;
+    }
+    console.log(chalk.cyan(`\n⬇️  Updating ${toUpdate.length} skill file(s)...\n`));
+    await syncSkills(skillDir, toUpdate);
+    console.log(chalk.cyan('\n✅ Update complete\n'));
+}))
+    .addCommand(new Command('list')
+    .description('List remote skills and local install status')
+    .option('--dir <path>', 'Skill directory')
+    .action(async (opts) => {
+    try {
+        const manifest = await fetchManifest();
+        const result = await checkSkills({ dir: opts.dir });
+        console.log(chalk.cyan('\n📦 SceneRok remote skills\n'));
+        printSkillDiff(result.skills);
+        console.log(chalk.dim(`\nManifest: ${Object.keys(manifest.skills).length} skills · source: ${manifest.source}`));
+        console.log(chalk.dim('Install router: scenerok skills install <platform>'));
+        console.log(chalk.dim('Sync all:       scenerok skills sync\n'));
+    }
+    catch (err) {
+        console.log(chalk.red(`❌ ${err.message}`));
+        process.exit(1);
+    }
+}))
+    .addCommand(new Command('platforms')
+    .description('List supported agent platforms')
+    .action(() => {
+    console.log(chalk.cyan('\n📦 Supported SceneRok skill platforms\n'));
+    console.log('  opencode  - OpenCode agent (.agents/skills/)');
+    console.log('  claude    - Claude Code (.claude/skills/)');
+    console.log('  codex     - OpenAI Codex (.codex/skills/)');
+    console.log('  cursor    - Cursor editor (.cursor/skills/)');
+    console.log('  aider     - Aider (.aider/skills/)');
+    console.log('');
+    console.log(chalk.dim('Install: scenerok skills install <platform> [--sync]'));
+}));

package/dist/commands/validate.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const validateCommand: Command;
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/commands/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4HpC,eAAO,MAAM,eAAe,SAoLxB,CAAC"}