@scenerok/cli 2.2.0

package/dist/lib/api.js

@@ -0,0 +1,160 @@
+import fetch from 'node-fetch';
+import { getBaseUrl, getApiToken } from './config.js';
+import { logDebug, logError } from './logger.js';
+class ApiError extends Error {
+    status;
+    responseBody;
+    constructor(message, status, responseBody) {
+        super(message);
+        this.status = status;
+        this.responseBody = responseBody;
+        this.name = 'ApiError';
+    }
+}
+function getAuthHeaders(contentType = 'application/json') {
+    const token = getApiToken();
+    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 url = `${baseUrl}${path}`;
+    const started = Date.now();
+    logDebug('API request', {
+        method,
+        url,
+        hasBody: body != null,
+    });
+    let response;
+    try {
+        response = await fetch(url, {
+            method,
+            headers: getAuthHeaders(),
+            body: body ? JSON.stringify(body) : undefined,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logError('API network error', { method, url, message });
+        throw new ApiError(`Network error: ${message}`, 0, { cause: message });
+    }
+    const rawText = await response.text();
+    let data = {};
+    if (rawText) {
+        try {
+            data = JSON.parse(rawText);
+        }
+        catch {
+            data = { raw: rawText.slice(0, 2000) };
+        }
+    }
+    const durationMs = Date.now() - started;
+    if (!response.ok) {
+        logError('API error response', {
+            method,
+            url,
+            status: response.status,
+            durationMs,
+            body: data,
+        });
+        throw new ApiError(data.error || `HTTP ${response.status}`, response.status, data);
+    }
+    logDebug('API success', { method, url, status: response.status, durationMs });
+    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, options = {}) {
+    return apiCall('POST', '/api/cli/validate', {
+        vidscript,
+        language: options.language || 'vidscript',
+        generateAssets: options.generateAssets || undefined,
+        moduleMap: options.moduleMap,
+        workingDirectory: options.workingDirectory,
+    });
+}
+export async function validateRender(renderId, options = {}) {
+    return apiCall('POST', '/api/cli/validate-render', {
+        renderId,
+        cost: options.cost,
+        frames: options.frames,
+        budgetUsd: options.budgetUsd,
+    });
+}
+export async function submitRender(vidscript, resolution, templateId, options = {}) {
+    return apiCall('POST', '/api/cli/render', {
+        vidscript,
+        resolution,
+        templateId,
+        language: options.language || 'vidscript',
+        moduleMap: options.moduleMap,
+        workingDirectory: options.workingDirectory,
+    });
+}
+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 uploadCliAssets(formData) {
+    return apiFormCall('/api/cli/assets', 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 checkAssetCache(cacheKeys) {
+    return apiCall('POST', '/api/cli/asset-cache/check', { cacheKeys });
+}
+export async function initiateDeviceAuth(deviceName) {
+    return apiCall('POST', '/api/cli/auth/device', { deviceName });
+}
+export async function pollDeviceAuth(deviceCode) {
+    return apiCall('GET', `/api/cli/auth/device?device_code=${deviceCode}`);
+}
+export { ApiError };

package/dist/lib/config.d.ts

@@ -0,0 +1,13 @@
+export interface CliConfig {
+    apiToken?: string;
+    baseUrl?: string;
+    defaultResolution?: string;
+}
+export declare function readConfig(): CliConfig;
+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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AASA,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;AAOD,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

@@ -0,0 +1,53 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+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');
+const PRODUCTION_API_ORIGIN = ['https://', 'scenerok', '.com'].join(''); // pragma: allowlist secret
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+export function readConfig() {
+    ensureConfigDir();
+    if (!existsSync(CONFIG_FILE)) {
+        return {};
+    }
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeConfig(config) {
+    ensureConfigDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function cliBaseUrlFromEnv() {
+    const key = ['SCENEROK', '_', 'BASE', '_', 'URL'].join('');
+    return process.env[key]?.replace(/\/$/, '');
+}
+export function getBaseUrl() {
+    const config = readConfig();
+    return config.baseUrl?.replace(/\/$/, '') || cliBaseUrlFromEnv() || PRODUCTION_API_ORIGIN;
+}
+export function getApiToken() {
+    const config = readConfig();
+    return config.apiToken;
+}
+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/format-api-error.d.ts

@@ -0,0 +1,2 @@
+export declare function formatApiErrorMessage(error: unknown): string;
+//# sourceMappingURL=format-api-error.d.ts.map

package/dist/lib/format-api-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-api-error.d.ts","sourceRoot":"","sources":["../../src/lib/format-api-error.ts"],"names":[],"mappings":"AAEA,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAwB5D"}

package/dist/lib/format-api-error.js

@@ -0,0 +1,24 @@
+import { ApiError } from './api.js';
+export function formatApiErrorMessage(error) {
+    if (error instanceof ApiError) {
+        const parts = [`HTTP ${error.status}: ${error.message}`];
+        const body = error.responseBody;
+        if (body && typeof body === 'object') {
+            const record = body;
+            if (typeof record.hint === 'string') {
+                parts.push(`Hint: ${record.hint}`);
+            }
+            if (typeof record.detail === 'string') {
+                parts.push(`Detail: ${record.detail}`);
+            }
+            if (typeof record.code === 'string') {
+                parts.push(`Code: ${record.code}`);
+            }
+        }
+        return parts.join('\n');
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist/lib/language.d.ts

@@ -0,0 +1,3 @@
+export type AuthoringLanguage = 'vidscript' | 'typescript' | 'javascript';
+export declare function detectAuthoringLanguage(filePath: string): AuthoringLanguage;
+//# sourceMappingURL=language.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"language.d.ts","sourceRoot":"","sources":["../../src/lib/language.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,YAAY,GAAG,YAAY,CAAC;AAE1E,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAK3E"}

package/dist/lib/language.js

@@ -0,0 +1,9 @@
+import { extname } from 'node:path';
+export function detectAuthoringLanguage(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    if (ext === '.ts' || ext === '.tsx')
+        return 'typescript';
+    if (ext === '.js' || ext === '.mjs' || ext === '.cjs')
+        return 'javascript';
+    return 'vidscript';
+}

package/dist/lib/logger.d.ts

@@ -0,0 +1,8 @@
+export declare function getLogFilePath(): string;
+export declare function isVerbose(): boolean;
+export declare function writeLog(level: 'debug' | 'info' | 'warn' | 'error', message: string, meta?: Record<string, unknown>): void;
+export declare function logDebug(message: string, meta?: Record<string, unknown>): void;
+export declare function logInfo(message: string, meta?: Record<string, unknown>): void;
+export declare function logWarn(message: string, meta?: Record<string, unknown>): void;
+export declare function logError(message: string, meta?: Record<string, unknown>): void;
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/lib/logger.ts"],"names":[],"mappings":"AAOA,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,SAAS,IAAI,OAAO,CAOnC;AAmBD,wBAAgB,QAAQ,CACtB,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAC1C,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,IAAI,CAIN;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAM9E;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAE7E;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAE7E;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAE9E"}

package/dist/lib/logger.js

@@ -0,0 +1,51 @@
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { getConfigDir } from './config.js';
+const LOG_DIR = join(getConfigDir(), 'logs');
+const LOG_FILE = join(LOG_DIR, 'cli.log');
+export function getLogFilePath() {
+    return LOG_FILE;
+}
+export function isVerbose() {
+    const verboseEnv = ['SCENEROK', '_', 'VERBOSE'].join('');
+    return (process.env[verboseEnv] === '1' ||
+        process.argv.includes('--verbose') ||
+        process.argv.includes('-v'));
+}
+function ensureLogDir() {
+    if (!existsSync(LOG_DIR)) {
+        mkdirSync(LOG_DIR, { recursive: true });
+    }
+}
+function formatMeta(meta) {
+    if (!meta || Object.keys(meta).length === 0) {
+        return '';
+    }
+    try {
+        return ` ${JSON.stringify(meta)}`;
+    }
+    catch {
+        return ' [meta unserializable]';
+    }
+}
+export function writeLog(level, message, meta) {
+    ensureLogDir();
+    const line = `[${new Date().toISOString()}] ${level.toUpperCase()} ${message}${formatMeta(meta)}\n`;
+    appendFileSync(LOG_FILE, line, 'utf-8');
+}
+export function logDebug(message, meta) {
+    writeLog('debug', message, meta);
+    if (isVerbose()) {
+        // eslint-disable-next-line no-console
+        console.error(`[debug] ${message}${formatMeta(meta)}`);
+    }
+}
+export function logInfo(message, meta) {
+    writeLog('info', message, meta);
+}
+export function logWarn(message, meta) {
+    writeLog('warn', message, meta);
+}
+export function logError(message, meta) {
+    writeLog('error', message, meta);
+}

package/dist/lib/project.d.ts

@@ -0,0 +1,29 @@
+export interface PreparedProject {
+    rootDir: string;
+    entryFile: string;
+    originalVidscript: string;
+    rewrittenVidscript: string;
+    assets: Array<{
+        localPath: string;
+        absolutePath: string;
+        size: number;
+        sha256: string;
+    }>;
+}
+export declare function getMimeType(filePath: string): 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>;
+export declare function buildAssetToken(localPath: string): string;
+export declare function rewritePreparedVidscriptWithAssetUrls(vidscript: string, mappings: Array<{
+    localPath: string;
+    url: string;
+}>): string;
+export declare function writeAssetManifest(project: PreparedProject, mappings: Array<{
+    localPath: string;
+    url: string;
+    id?: number;
+    mimeType?: string | null;
+    fileSize?: number;
+}>): string;
+//# 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":"AASA,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;QACrB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;CACJ;AAcD,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAepD;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAoBzD;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,GAAE,MAAM,EAAO,GAAG,eAAe,CAiE3F;AAED,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAcrG;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,qCAAqC,CACnD,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,KAAK,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAClD,MAAM,CAMR;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,KAAK,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAC5G,MAAM,CAwBR"}

package/dist/lib/project.js

@@ -0,0 +1,156 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } 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 ASSET_IMPORT_RE = /^(\s*)import\s+([A-Za-z_][A-Za-z0-9_]*)\s+from\s+(["'])([^"']+)\3\s*;?\s*$/gm;
+const HTTP_RE = /^https?:\/\//i;
+const MEDIA_EXT_RE = /\.(mp4|mov|m4v|webm|mp3|wav|m4a|aac|ogg|png|jpe?g|webp|gif|avif|svg)(?:[?#].*)?$/i;
+function isRenderableLocalPath(value) {
+    return Boolean(value)
+        && !HTTP_RE.test(value)
+        && !value.startsWith('scenerok://')
+        && !value.startsWith('/uploads/')
+        && !value.startsWith('data:');
+}
+function isAssetImportPath(value) {
+    return isRenderableLocalPath(value) && MEDIA_EXT_RE.test(value);
+}
+export 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}`;
+    });
+    rewrittenVidscript = rewrittenVidscript.replace(ASSET_IMPORT_RE, (match, indent, localName, _quote, rawPath) => {
+        if (!isAssetImportPath(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 `${indent}input ${localName} = "{{asset:${localPath}}}"`;
+    });
+    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,
+            size: statSync(absolutePath).size,
+            sha256: createHash('sha256').update(readFileSync(absolutePath)).digest('hex'),
+        })),
+    };
+}
+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);
+}
+export function buildAssetToken(localPath) {
+    return `__SCENEROK_ASSET_${Buffer.from(localPath).toString('base64url')}__`;
+}
+export function rewritePreparedVidscriptWithAssetUrls(vidscript, mappings) {
+    let next = vidscript;
+    for (const mapping of mappings) {
+        next = next.replaceAll(buildAssetToken(mapping.localPath), mapping.url);
+    }
+    return next;
+}
+export function writeAssetManifest(project, mappings) {
+    const manifestDir = join(project.rootDir, '.scenerok');
+    mkdirSync(manifestDir, { recursive: true });
+    const manifestPath = join(manifestDir, 'assets.manifest.json');
+    const byLocalPath = new Map(project.assets.map((asset) => [asset.localPath, asset]));
+    const manifest = {
+        version: 1,
+        entryFile: project.entryFile,
+        generatedAt: new Date().toISOString(),
+        assets: mappings.map((mapping) => {
+            const localAsset = byLocalPath.get(mapping.localPath);
+            return {
+                localPath: mapping.localPath,
+                absolutePath: localAsset?.absolutePath,
+                size: localAsset?.size ?? mapping.fileSize,
+                sha256: localAsset?.sha256,
+                assetId: mapping.id,
+                mimeType: mapping.mimeType,
+                url: mapping.url,
+            };
+        }),
+    };
+    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    return manifestPath;
+}

package/dist/lib/sdk-scene-modules.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Collect companion `@scenerok/sdk` scene files referenced from VidScript
+ * so the CLI can upload them as a moduleMap for remote compile.
+ */
+export declare function buildSdkSceneModuleMap(vidscript: string, baseDir: string): Record<string, string>;
+export declare function resolveEntryWorkingDirectory(filePath: string): string;
+//# sourceMappingURL=sdk-scene-modules.d.ts.map

package/dist/lib/sdk-scene-modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-scene-modules.d.ts","sourceRoot":"","sources":["../../src/lib/sdk-scene-modules.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAeH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAexB;AAED,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAErE"}

package/dist/lib/sdk-scene-modules.js

@@ -0,0 +1,35 @@
+/**
+ * Collect companion `@scenerok/sdk` scene files referenced from VidScript
+ * so the CLI can upload them as a moduleMap for remote compile.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+const SDK_SCENE_EXT_RE = /\.(tsx?|jsx?|mjs|cjs)$/i;
+const SDK_IMPORT_RE = /^\s*import\s+[A-Za-z_][A-Za-z0-9_]*\s+from\s+(["'])([^"']+)\1\s*;?\s*$/gm;
+function isSdkSceneSpecifier(specifier) {
+    if (!specifier || specifier.startsWith('@'))
+        return false;
+    const pathOnly = specifier.split('?')[0].split('#')[0];
+    return SDK_SCENE_EXT_RE.test(pathOnly);
+}
+export function buildSdkSceneModuleMap(vidscript, baseDir) {
+    const moduleMap = {};
+    SDK_IMPORT_RE.lastIndex = 0;
+    let match;
+    while ((match = SDK_IMPORT_RE.exec(vidscript)) !== null) {
+        const specifier = match[2];
+        if (!isSdkSceneSpecifier(specifier))
+            continue;
+        if (!(specifier.startsWith('./') || specifier.startsWith('../') || isAbsolute(specifier))) {
+            continue;
+        }
+        const absolute = isAbsolute(specifier) ? specifier : resolve(baseDir, specifier);
+        if (!existsSync(absolute))
+            continue;
+        moduleMap[specifier] = readFileSync(absolute, 'utf-8');
+    }
+    return moduleMap;
+}
+export function resolveEntryWorkingDirectory(filePath) {
+    return dirname(resolve(filePath));
+}

package/dist/utils/skillsManifest.d.ts

@@ -0,0 +1,42 @@
+export declare const DEFAULT_MANIFEST_URL = "https://scenerok.com/.well-known/agent-skills/manifest.json";
+export interface SkillEntry {
+    hash: string;
+    files: number;
+}
+export interface SkillsManifest {
+    source: string;
+    skills: Record<string, SkillEntry>;
+}
+export type SkillStatus = 'current' | 'outdated' | 'missing';
+export interface SkillDiff {
+    name: string;
+    status: SkillStatus;
+    installedHash?: string;
+    latestHash?: string;
+    filename: string;
+}
+export interface SkillsCheckResult {
+    location: string | null;
+    updateAvailable: boolean;
+    summary: {
+        current: number;
+        outdated: number;
+        missing: number;
+    };
+    skills: SkillDiff[];
+}
+/** Map manifest slug to on-disk filename. */
+export declare function slugToFilename(slug: string): string;
+export declare function hashInstalledFile(filePath: string): SkillEntry | null;
+export declare function hashInstalled(skillDir: string, manifest: SkillsManifest): Record<string, SkillEntry>;
+export declare function diffSkills(installed: Record<string, SkillEntry>, latest: SkillsManifest): Omit<SkillsCheckResult, 'location'>;
+export declare function fetchManifest(url?: string): Promise<SkillsManifest>;
+export declare function fetchSkillFile(slug: string, baseUrl?: string): Promise<string>;
+export declare function locateSkillDir(platform?: string): string | null;
+export declare function checkSkills(opts?: {
+    dir?: string;
+    manifestUrl?: string;
+}): Promise<SkillsCheckResult>;
+/** List extra local files not in manifest (legacy bundled files). */
+export declare function listExtraLocalFiles(skillDir: string, manifest: SkillsManifest): string[];
+//# sourceMappingURL=skillsManifest.d.ts.map

package/dist/utils/skillsManifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillsManifest.d.ts","sourceRoot":"","sources":["../../src/utils/skillsManifest.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,oBAAoB,gEAC8B,CAAC;AAEhE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACpC;AAED,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;AAE7D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IACzB,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAChE,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAWD,6CAA6C;AAC7C,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAKrE;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAQpG;AAED,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACrC,MAAM,EAAE,cAAc,GACrB,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,CA8BrC;AAED,wBAAsB,aAAa,CAAC,GAAG,SAAuB,GAAG,OAAO,CAAC,cAAc,CAAC,CAQvF;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOpF;AAED,wBAAgB,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiB/D;AAED,wBAAsB,WAAW,CAAC,IAAI,GAAE;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAMlC;AAED,qEAAqE;AACrE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,EAAE,CAKxF"}