@feralfile/cli 1.1.1

package/dist/src/commands/status.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const config_files_1 = require("./helpers/config-files");
+const config_1 = require("../config");
+const ed25519_key_derive_1 = require("../utilities/ed25519-key-derive");
+const playlist_signing_role_1 = require("../utilities/playlist-signing-role");
+exports.statusCommand = new commander_1.Command('status')
+    .description('Show configuration status')
+    .action(async () => {
+    try {
+        const configPath = await (0, config_files_1.resolveExistingConfigPath)();
+        if (!configPath) {
+            console.log(chalk_1.default.red('config.json not found'));
+            console.log(chalk_1.default.dim('Run: ff1 setup'));
+            process.exit(1);
+        }
+        const config = await (0, config_files_1.readConfigFile)(configPath);
+        const modelNames = Object.keys(config.models || {});
+        const defaultModel = config.defaultModel && modelNames.includes(config.defaultModel)
+            ? config.defaultModel
+            : modelNames[0];
+        const defaultModelLabel = defaultModel || 'unknown';
+        const defaultModelConfig = defaultModel ? config.models?.[defaultModel] : undefined;
+        const playlistConfig = (0, config_1.getPlaylistConfig)();
+        const hasApiKey = defaultModel ? !(0, config_files_1.isMissingConfigValue)(defaultModelConfig?.apiKey) : false;
+        const playlistKeyMaterial = playlistConfig.privateKey?.trim() || '';
+        const playlistKeyError = playlistKeyMaterial.length > 0 ? validatePlaylistPrivateKey(playlistKeyMaterial) : null;
+        const hasPlaylistSigningKey = playlistKeyMaterial.length > 0 && playlistKeyError === null;
+        let hasValidPlaylistRole = false;
+        let playlistRoleDetail;
+        let playlistRoleError;
+        const playlistRoleMaterial = playlistConfig.role?.trim() || '';
+        if (playlistRoleMaterial) {
+            hasValidPlaylistRole = (0, playlist_signing_role_1.isDp1PlaylistSigningRole)(playlistRoleMaterial);
+            playlistRoleDetail = playlistRoleMaterial;
+            if (!hasValidPlaylistRole) {
+                playlistRoleError = playlistRoleMaterial;
+            }
+        }
+        const statuses = [
+            {
+                label: 'Config file',
+                ok: true,
+                detail: configPath,
+            },
+            {
+                label: `Default model (${defaultModelLabel}) API key`,
+                ok: hasApiKey,
+                optional: true,
+                hint: ' (needed for chat)',
+            },
+            {
+                label: 'Playlist signing key',
+                ok: hasPlaylistSigningKey,
+                optional: false,
+                detail: playlistKeyError
+                    ? `${playlistKeyError} (from config/env)`
+                    : playlistKeyMaterial
+                        ? 'from config/env'
+                        : undefined,
+                hint: ' (needed for signing and legacy verification)',
+            },
+            {
+                label: 'Playlist signing role',
+                ok: hasValidPlaylistRole,
+                optional: true,
+                detail: playlistRoleDetail,
+                invalid: Boolean(playlistRoleError),
+                hint: ' (used when signing playlists)',
+            },
+            {
+                label: `FF1 devices (${config.ff1Devices?.devices?.length || 0})`,
+                ok: (config.ff1Devices?.devices?.length || 0) > 0 &&
+                    (config.ff1Devices?.devices || []).every((d) => !(0, config_files_1.isMissingConfigValue)(d.host)),
+                detail: (config.ff1Devices?.devices || [])
+                    .map((d) => `${d.name || 'unnamed'} → ${d.host}`)
+                    .join(', ') || undefined,
+            },
+        ];
+        console.log(chalk_1.default.blue('\n🔎 FF1 Status\n'));
+        statuses.forEach((status) => {
+            let label;
+            if (status.ok) {
+                label = chalk_1.default.green('OK');
+            }
+            else if (status.invalid) {
+                label = chalk_1.default.red('Invalid');
+            }
+            else if (status.optional) {
+                label = chalk_1.default.yellow('Not set');
+            }
+            else {
+                label = chalk_1.default.red('Missing');
+            }
+            const detail = status.detail ? chalk_1.default.dim(` (${status.detail})`) : '';
+            const hint = status.ok || !status.hint
+                ? ''
+                : chalk_1.default.dim(status.hint);
+            console.log(`${label} ${status.label}${detail}${hint}`);
+        });
+        const hasRequired = statuses.some((status) => !status.ok && (!status.optional || Boolean(status.invalid)));
+        if (hasRequired) {
+            console.log(chalk_1.default.dim('\nRun: ff1 setup'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nStatus check failed:'), error.message);
+        process.exit(1);
+    }
+});
+function validatePlaylistPrivateKey(material) {
+    try {
+        (0, ed25519_key_derive_1.parsePlaylistPrivateKeyToKeyObject)(material);
+        return null;
+    }
+    catch (error) {
+        return error.message;
+    }
+}

package/dist/src/commands/validate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCommand = exports.verifyCommand = void 0;
+const commander_1 = require("commander");
+const playlist_display_1 = require("./helpers/playlist-display");
+exports.verifyCommand = new commander_1.Command('verify')
+    .description('Validate playlist structure and verify DP-1 signatures')
+    .argument('<file>', 'Path to the playlist file or hosted playlist URL')
+    .option('--public-key <publicKey>', 'Ed25519 public key for legacy verification (overrides deriving from playlist.privateKey / PLAYLIST_PRIVATE_KEY)')
+    .action(async (file, options) => {
+    await (0, playlist_display_1.runVerifyCommand)(file, options.publicKey);
+});
+exports.validateCommand = new commander_1.Command('validate')
+    .description('Validate playlist structure only')
+    .argument('<file>', 'Path to the playlist file or hosted playlist URL')
+    .action(async (file) => {
+    await (0, playlist_display_1.runValidateCommand)(file);
+});

package/dist/src/config.js

@@ -0,0 +1,441 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigPaths = getConfigPaths;
+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"));
+const os_1 = __importDefault(require("os"));
+const playlist_signing_role_1 = require("./utilities/playlist-signing-role");
+// One-shot legacy config migration: copy `$XDG_CONFIG_HOME/ff1/config.json` to
+// `$XDG_CONFIG_HOME/ff-cli/config.json` on first read after upgrading from
+// `ff1-cli`. The check is cheap (two fs.existsSync calls) and the
+// `migrationChecked` flag keeps it to one attempt per process.
+//
+// Remove this block after a release cycle once telemetry suggests no remaining
+// users still have only the legacy path populated.
+let migrationChecked = false;
+function migrateLegacyConfigIfNeeded(newUserPath) {
+    if (migrationChecked) {
+        return;
+    }
+    migrationChecked = true;
+    const configBase = process.env.XDG_CONFIG_HOME || path_1.default.join(os_1.default.homedir(), '.config');
+    const legacyUserPath = path_1.default.join(configBase, 'ff1', 'config.json');
+    if (!fs_1.default.existsSync(legacyUserPath) || fs_1.default.existsSync(newUserPath)) {
+        return;
+    }
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(newUserPath), { recursive: true });
+        fs_1.default.copyFileSync(legacyUserPath, newUserPath);
+        console.log(`Migrated config from ${legacyUserPath} to ${newUserPath}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Warning: Failed to migrate legacy config from ${legacyUserPath}: ${message}`);
+    }
+}
+function getConfigPaths() {
+    const localPath = path_1.default.join(process.cwd(), 'config.json');
+    const configBase = process.env.XDG_CONFIG_HOME || path_1.default.join(os_1.default.homedir(), '.config');
+    const userPath = path_1.default.join(configBase, 'ff-cli', 'config.json');
+    migrateLegacyConfigIfNeeded(userPath);
+    return { localPath, userPath };
+}
+/**
+ * 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 { localPath, userPath } = getConfigPaths();
+    // Default configuration supporting Grok as default
+    const defaultConfig = {
+        defaultModel: process.env.DEFAULT_MODEL || 'claude',
+        models: {
+            claude: {
+                apiKey: process.env.ANTHROPIC_API_KEY || '',
+                baseURL: 'https://api.anthropic.com/v1/',
+                model: 'claude-sonnet-4-6',
+                availableModels: ['claude-opus-4-7', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001'],
+                timeout: 30000,
+                maxRetries: 3,
+                temperature: 0.3,
+                maxTokens: 4000,
+                supportsFunctionCalling: true,
+            },
+            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,
+            },
+            gpt: {
+                apiKey: process.env.OPENAI_API_KEY || '',
+                baseURL: 'https://api.openai.com/v1',
+                model: 'gpt-4.1',
+                availableModels: ['gpt-4.1', 'gpt-4.1-mini', '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://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1'],
+        },
+    };
+    // Try to load config.json if it exists
+    const configPath = fs_1.default.existsSync(localPath) ? localPath : userPath;
+    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) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Warning: Failed to parse config at ${configPath}. ${message}. 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 signing private key and role.
+ *
+ * @returns {Object} Playlist configuration
+ * @returns {string|null} returns.privateKey - Ed25519 private key in base64 or hex format (null if not configured)
+ * @returns {string|null} returns.role - DP-1 signing role (null if not configured)
+ */
+function getPlaylistConfig() {
+    const config = getConfig();
+    const playlistConfig = config.playlist || {};
+    return {
+        privateKey: playlistConfig.privateKey || process.env.PLAYLIST_PRIVATE_KEY || null,
+        role: playlistConfig.role || process.env.PLAYLIST_ROLE || null,
+    };
+}
+/**
+ * Resolve the effective playlist signing role used by runtime paths.
+ *
+ * Validation must inspect the same value that setup and signing use so
+ * preflight checks do not accept combinations that will fail later, or reject
+ * whitespace-padded values that runtime trims before validation.
+ *
+ * @param {Config} config - Loaded configuration object.
+ * @returns {string|null} Effective role after config/env fallback and trimming.
+ */
+function resolveEffectivePlaylistRole(config) {
+    const playlistConfig = config.playlist || {};
+    const configuredRole = playlistConfig.role || process.env.PLAYLIST_ROLE || null;
+    if (configuredRole === null) {
+        return null;
+    }
+    return (0, playlist_signing_role_1.resolveDp1PlaylistSigningRole)(configuredRole);
+}
+/**
+ * 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://dp1-feed-operator-api-prod.autonomy-system.workers.dev/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;
+            const placeholderPattern = /your_ed25519_private_key/i;
+            if (!placeholderPattern.test(key) && typeof key === 'string' && key.length > 0) {
+                const base64Regex = /^[A-Za-z0-9+/]+=*$/;
+                const hexRegex = /^(0x)?[0-9a-fA-F]+$/;
+                if (!base64Regex.test(key) && !hexRegex.test(key)) {
+                    errors.push('playlist.privateKey must be a valid base64- or hex-encoded ed25519 private key');
+                }
+            }
+        }
+        if (config.playlist?.role !== undefined || process.env.PLAYLIST_ROLE !== undefined) {
+            try {
+                resolveEffectivePlaylistRole(config);
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    error.message.startsWith('Unsupported DP-1 playlist signing role')) {
+                    errors.push(`playlist.role must be one of: ${playlist_signing_role_1.DP1_PLAYLIST_SIGNING_ROLES.join(', ')}`);
+                }
+                else {
+                    errors.push(error.message);
+                }
+            }
+        }
+        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(targetPath) {
+    const { userPath } = getConfigPaths();
+    const configPath = targetPath || userPath;
+    // 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 exampleCandidates = [
+        path_1.default.join(process.cwd(), 'config.json.example'),
+        path_1.default.join(__dirname, '../..', 'config.json.example'),
+    ];
+    const examplePath = exampleCandidates.find((candidate) => fs_1.default.existsSync(candidate));
+    if (!examplePath) {
+        throw new Error('config.json.example not found. This is likely a package installation issue.');
+    }
+    const exampleConfig = fs_1.default.readFileSync(examplePath, 'utf-8');
+    fs_1.default.mkdirSync(path_1.default.dirname(configPath), { recursive: true });
+    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);
+}