ff1-cli 1.0.0

package/dist/src/ai-orchestrator/registry.js

@@ -0,0 +1,96 @@
+/**
+ * In-Memory Registry for Playlists and Items
+ * Reduces AI context usage by storing full objects and passing only IDs
+ */
+// Internal storage
+const itemRegistry = new Map();
+const playlistRegistry = new Map();
+/**
+ * Store a playlist item in the registry
+ *
+ * @param {string} id - Item ID
+ * @param {Object} item - Full DP1 item object
+ */
+function storeItem(id, item) {
+    if (!id) {
+        throw new Error('Item ID is required');
+    }
+    itemRegistry.set(id, item);
+}
+/**
+ * Retrieve a playlist item from the registry
+ *
+ * @param {string} id - Item ID
+ * @returns {Object|undefined} DP1 item object or undefined
+ */
+function getItem(id) {
+    return itemRegistry.get(id);
+}
+/**
+ * Check if an item exists in the registry
+ *
+ * @param {string} id - Item ID
+ * @returns {boolean} True if item exists
+ */
+function hasItem(id) {
+    return itemRegistry.has(id);
+}
+/**
+ * Store a playlist in the registry
+ *
+ * @param {string} id - Playlist ID
+ * @param {Object} playlist - Full DP1 playlist object
+ */
+function storePlaylist(id, playlist) {
+    if (!id) {
+        throw new Error('Playlist ID is required');
+    }
+    playlistRegistry.set(id, playlist);
+}
+/**
+ * Retrieve a playlist from the registry
+ *
+ * @param {string} id - Playlist ID
+ * @returns {Object|undefined} DP1 playlist object or undefined
+ */
+function getPlaylist(id) {
+    return playlistRegistry.get(id);
+}
+/**
+ * Check if a playlist exists in the registry
+ *
+ * @param {string} id - Playlist ID
+ * @returns {boolean} True if playlist exists
+ */
+function hasPlaylist(id) {
+    return playlistRegistry.has(id);
+}
+/**
+ * Clear all registries
+ * Should be called after successful playlist build or on error
+ */
+function clearRegistries() {
+    itemRegistry.clear();
+    playlistRegistry.clear();
+}
+/**
+ * Get registry statistics (for debugging)
+ *
+ * @returns {Object} Registry stats
+ */
+function getStats() {
+    return {
+        itemCount: itemRegistry.size,
+        playlistCount: playlistRegistry.size,
+    };
+}
+module.exports = {
+    storeItem,
+    getItem,
+    hasItem,
+    storePlaylist,
+    getPlaylist,
+    hasPlaylist,
+    clearRegistries,
+    getStats,
+};

package/dist/src/config.js

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = getConfig;
+exports.sanitizationLevelToNumber = sanitizationLevelToNumber;
+exports.getBrowserConfig = getBrowserConfig;
+exports.getPlaylistConfig = getPlaylistConfig;
+exports.getFeedConfig = getFeedConfig;
+exports.getFF1DeviceConfig = getFF1DeviceConfig;
+exports.getModelConfig = getModelConfig;
+exports.validateConfig = validateConfig;
+exports.createSampleConfig = createSampleConfig;
+exports.listAvailableModels = listAvailableModels;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Load configuration from config.json or environment variables
+ * Priority: config.json > .env > defaults
+ *
+ * @returns {Object} Configuration object with model settings
+ * @returns {string} returns.defaultModel - Name of the default model to use
+ * @returns {Object} returns.models - Available models configuration
+ * @returns {number} returns.defaultDuration - Default duration per item in seconds
+ */
+function loadConfig() {
+    const configPath = path_1.default.join(process.cwd(), 'config.json');
+    // Default configuration supporting Grok as default
+    const defaultConfig = {
+        defaultModel: process.env.DEFAULT_MODEL || 'grok',
+        models: {
+            grok: {
+                apiKey: process.env.GROK_API_KEY || '',
+                baseURL: process.env.GROK_API_BASE_URL || 'https://api.x.ai/v1',
+                model: process.env.GROK_MODEL || 'grok-beta',
+                availableModels: ['grok-beta', 'grok-2-1212', 'grok-2-vision-1212'],
+                timeout: parseInt(process.env.TIMEOUT || '30000', 10),
+                maxRetries: parseInt(process.env.MAX_RETRIES || '3', 10),
+                temperature: parseFloat(process.env.TEMPERATURE || '0.3'),
+                maxTokens: parseInt(process.env.MAX_TOKENS || '4000', 10),
+                supportsFunctionCalling: true,
+            },
+            chatgpt: {
+                apiKey: process.env.OPENAI_API_KEY || '',
+                baseURL: 'https://api.openai.com/v1',
+                model: 'gpt-4o',
+                availableModels: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo'],
+                timeout: 30000,
+                maxRetries: 3,
+                temperature: 0.3,
+                maxTokens: 4000,
+                supportsFunctionCalling: true,
+            },
+            gemini: {
+                apiKey: process.env.GEMINI_API_KEY || '',
+                baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+                model: 'gemini-2.5-flash',
+                availableModels: ['gemini-2.5-flash-lite', 'gemini-2.5-flash', 'gemini-flash-lite-latest'],
+                timeout: 30000,
+                maxRetries: 3,
+                temperature: 0.3,
+                maxTokens: 4000,
+                supportsFunctionCalling: true,
+            },
+        },
+        defaultDuration: parseInt(process.env.DEFAULT_DURATION || '10', 10),
+        browser: {
+            timeout: parseInt(process.env.BROWSER_TIMEOUT || '90000', 10),
+            sanitizationLevel: process.env.SANITIZATION_LEVEL || 'medium',
+        },
+        feed: {
+            baseURLs: process.env.FEED_BASE_URLS
+                ? process.env.FEED_BASE_URLS.split(',')
+                : ['https://feed.feralfile.com/api/v1'],
+        },
+    };
+    // Try to load config.json if it exists
+    if (fs_1.default.existsSync(configPath)) {
+        try {
+            const fileConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+            // Deep merge models configuration
+            const mergedModels = { ...defaultConfig.models };
+            if (fileConfig.models) {
+                Object.keys(fileConfig.models).forEach((modelName) => {
+                    mergedModels[modelName] = {
+                        ...(defaultConfig.models[modelName] || {}),
+                        ...fileConfig.models[modelName],
+                    };
+                });
+            }
+            // Merge with defaults, file config takes precedence
+            return {
+                ...defaultConfig,
+                ...fileConfig,
+                models: mergedModels,
+            };
+        }
+        catch (_error) {
+            console.warn('Warning: Failed to parse config.json, using defaults');
+            return defaultConfig;
+        }
+    }
+    // Return default config if no file exists
+    return defaultConfig;
+}
+/**
+ * Get current configuration
+ *
+ * @returns {Object} Current configuration
+ */
+function getConfig() {
+    return loadConfig();
+}
+/**
+ * Convert sanitization level string to numeric value
+ *
+ * @param {string|number} level - Sanitization level ('none', 'low', 'medium', 'high') or number (0-3)
+ * @returns {number} Numeric level (0 = none, 1 = low, 2 = medium, 3 = high)
+ */
+function sanitizationLevelToNumber(level) {
+    if (typeof level === 'number') {
+        return level;
+    }
+    const levelMap = {
+        none: 0,
+        low: 1,
+        medium: 2,
+        high: 3,
+    };
+    return levelMap[level] !== undefined ? levelMap[level] : 2; // Default to medium (2)
+}
+/**
+ * Get browser configuration
+ *
+ * @returns {Object} Browser configuration
+ * @returns {number} returns.timeout - Browser timeout in milliseconds
+ * @returns {number} returns.sanitizationLevel - Numeric sanitization level (0-3)
+ */
+function getBrowserConfig() {
+    const config = getConfig();
+    const browserConfig = config.browser || {
+        timeout: 90000,
+        sanitizationLevel: 'medium',
+    };
+    return {
+        timeout: browserConfig.timeout,
+        sanitizationLevel: sanitizationLevelToNumber(browserConfig.sanitizationLevel),
+    };
+}
+/**
+ * Get playlist configuration including private key for signing
+ *
+ * @returns {Object} Playlist configuration
+ * @returns {string|null} returns.privateKey - Ed25519 private key in base64 format (null if not configured)
+ */
+function getPlaylistConfig() {
+    const config = getConfig();
+    const playlistConfig = config.playlist || {};
+    return {
+        privateKey: playlistConfig.privateKey || process.env.PLAYLIST_PRIVATE_KEY || null,
+    };
+}
+/**
+ * Get feed configuration for DP1 feed API
+ *
+ * Supports both legacy (feed.baseURLs/apiKey) and new (feedServers array) formats.
+ *
+ * @returns {Object} Feed configuration
+ * @returns {string[]} returns.baseURLs - Array of base URLs for feed APIs
+ * @returns {string} [returns.apiKey] - Optional API key for authentication (legacy)
+ * @returns {Array<Object>} [returns.servers] - Array of feed servers with individual API keys (new)
+ */
+function getFeedConfig() {
+    const config = getConfig();
+    // Check for new feedServers format first
+    if (config.feedServers && Array.isArray(config.feedServers) && config.feedServers.length > 0) {
+        const baseURLs = config.feedServers.map((server) => server.baseUrl);
+        return {
+            baseURLs,
+            servers: config.feedServers,
+        };
+    }
+    // Fall back to legacy feed format
+    const feedConfig = config.feed || {};
+    // Support both legacy baseURL and new baseURLs
+    let urls = [];
+    if (feedConfig.baseURLs && Array.isArray(feedConfig.baseURLs)) {
+        urls = feedConfig.baseURLs;
+    }
+    else if (feedConfig.baseURL) {
+        urls = [feedConfig.baseURL];
+    }
+    else {
+        // Default feed URL
+        urls = ['https://feed.feralfile.com/api/v1'];
+    }
+    return {
+        baseURLs: urls,
+        apiKey: feedConfig.apiKey,
+    };
+}
+/**
+ * Get FF1 device configuration for casting playlists
+ *
+ * @returns {Object} FF1 device configuration
+ * @returns {Array<Object>} returns.devices - Array of configured FF1 devices
+ * @returns {string} returns.devices[].host - Device host URL
+ * @returns {string} [returns.devices[].apiKey] - Optional device API key
+ * @returns {string} [returns.devices[].topicID] - Optional device topic ID
+ * @returns {string} [returns.devices[].name] - Optional device name
+ */
+function getFF1DeviceConfig() {
+    const config = getConfig();
+    const ff1Devices = config.ff1Devices || { devices: [] };
+    return {
+        devices: ff1Devices.devices || [],
+    };
+}
+/**
+ * Get configuration for a specific model
+ *
+ * @param {string} [modelName] - Name of the model (defaults to defaultModel from config)
+ * @returns {Object} Model configuration
+ * @returns {string} returns.apiKey - API key for the model
+ * @returns {string} returns.baseURL - Base URL for the API
+ * @returns {string} returns.model - Model name/identifier
+ * @returns {number} returns.timeout - Request timeout in milliseconds
+ * @returns {number} returns.maxRetries - Maximum number of retries
+ * @returns {number} returns.temperature - Temperature for generation
+ * @returns {number} returns.maxTokens - Maximum tokens for generation
+ * @returns {boolean} returns.supportsFunctionCalling - Whether model supports function calling
+ * @throws {Error} If model is not configured or doesn't support function calling
+ */
+function getModelConfig(modelName) {
+    const config = getConfig();
+    const selectedModel = modelName || config.defaultModel;
+    if (!config.models[selectedModel]) {
+        throw new Error(`Model "${selectedModel}" is not configured. Available models: ${Object.keys(config.models).join(', ')}`);
+    }
+    const modelConfig = config.models[selectedModel];
+    if (!modelConfig.supportsFunctionCalling) {
+        throw new Error(`Model "${selectedModel}" does not support function calling`);
+    }
+    const normalizedBaseURL = modelConfig.baseURL?.replace(/\/+$/, '');
+    return {
+        ...modelConfig,
+        baseURL: normalizedBaseURL,
+        defaultDuration: config.defaultDuration,
+    };
+}
+/**
+ * Validate configuration for a specific model
+ *
+ * @param {string} [modelName] - Name of the model to validate
+ * @returns {Object} Validation result
+ * @returns {boolean} returns.valid - Whether the configuration is valid
+ * @returns {Array<string>} returns.errors - List of validation errors
+ */
+function validateConfig(modelName) {
+    const errors = [];
+    try {
+        const config = getConfig();
+        const selectedModel = modelName || config.defaultModel;
+        if (!config.models[selectedModel]) {
+            errors.push(`Model "${selectedModel}" is not configured. Available: ${Object.keys(config.models).join(', ')}`);
+            return { valid: false, errors };
+        }
+        const modelConfig = config.models[selectedModel];
+        if (!modelConfig.apiKey || modelConfig.apiKey === 'your_api_key_here') {
+            errors.push(`API key for "${selectedModel}" is missing or not configured`);
+        }
+        if (!modelConfig.baseURL) {
+            errors.push(`Base URL for "${selectedModel}" is missing`);
+        }
+        if (!modelConfig.model) {
+            errors.push(`Model identifier for "${selectedModel}" is not set`);
+        }
+        if (!modelConfig.supportsFunctionCalling) {
+            errors.push(`Model "${selectedModel}" does not support function calling (required)`);
+        }
+        // Validate browser configuration
+        if (config.browser) {
+            if (config.browser.timeout && typeof config.browser.timeout !== 'number') {
+                errors.push('Browser timeout must be a number');
+            }
+            const validLevels = ['none', 'low', 'medium', 'high'];
+            if (config.browser.sanitizationLevel &&
+                !validLevels.includes(config.browser.sanitizationLevel) &&
+                typeof config.browser.sanitizationLevel !== 'number') {
+                errors.push(`Invalid browser.sanitizationLevel: "${config.browser.sanitizationLevel}". Must be one of: ${validLevels.join(', ')} or 0-3`);
+            }
+        }
+        // Validate playlist configuration (optional, but warn if configured incorrectly)
+        if (config.playlist && config.playlist.privateKey) {
+            const key = config.playlist.privateKey;
+            if (key !== 'your_ed25519_private_key_base64_here' &&
+                typeof key === 'string' &&
+                key.length > 0) {
+                // Check if it looks like valid base64
+                const base64Regex = /^[A-Za-z0-9+/]+=*$/;
+                if (!base64Regex.test(key)) {
+                    errors.push('playlist.privateKey must be a valid base64-encoded ed25519 private key');
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    catch (error) {
+        errors.push(error.message);
+        return { valid: false, errors };
+    }
+}
+/**
+ * Create a sample config.json file from config.json.example
+ *
+ * Loads the bundled config.json.example template from the package directory
+ * and writes it to the user's current working directory.
+ *
+ * @returns {Promise<string>} Path to the created config file
+ * @throws {Error} If config.json already exists or example file is missing
+ */
+async function createSampleConfig() {
+    const configPath = path_1.default.join(process.cwd(), 'config.json');
+    // Check if config.json already exists in user's directory
+    if (fs_1.default.existsSync(configPath)) {
+        throw new Error('config.json already exists');
+    }
+    // Look for config.json.example in the package directory
+    // When compiled, this file is in dist/src/config.js
+    // The template is at the package root: ../../config.json.example
+    const packageRoot = path_1.default.join(__dirname, '../..');
+    const examplePath = path_1.default.join(packageRoot, 'config.json.example');
+    if (!fs_1.default.existsSync(examplePath)) {
+        throw new Error(`config.json.example not found at ${examplePath}. This is likely a package installation issue.`);
+    }
+    const exampleConfig = fs_1.default.readFileSync(examplePath, 'utf-8');
+    fs_1.default.writeFileSync(configPath, exampleConfig, 'utf-8');
+    return configPath;
+}
+/**
+ * List all available models
+ *
+ * @returns {Array<string>} List of available model names
+ */
+function listAvailableModels() {
+    const config = getConfig();
+    return Object.keys(config.models);
+}