ff1-cli 1.0.1 → 1.0.3

package/dist/src/config.js

@@ -52,8 +52,8 @@ function loadConfig() {
             gpt: {
                 apiKey: process.env.OPENAI_API_KEY || '',
                 baseURL: 'https://api.openai.com/v1',
-                model: 'gpt-4o',
-                availableModels: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo'],
+                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,
@@ -80,7 +80,7 @@ function loadConfig() {
         feed: {
             baseURLs: process.env.FEED_BASE_URLS
                 ? process.env.FEED_BASE_URLS.split(',')
-                : ['https://feed.feralfile.com/api/v1'],
+                : ['https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1'],
         },
     };
     // Try to load config.json if it exists
@@ -105,8 +105,9 @@ function loadConfig() {
                 models: mergedModels,
             };
         }
-        catch (_error) {
-            console.warn('Warning: Failed to parse config.json, using defaults');
+        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;
         }
     }
@@ -161,7 +162,7 @@ function getBrowserConfig() {
  * 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)
+ * @returns {string|null} returns.privateKey - Ed25519 private key in base64 or hex format (null if not configured)
  */
 function getPlaylistConfig() {
     const config = getConfig();
@@ -202,7 +203,7 @@ function getFeedConfig() {
     }
     else {
         // Default feed URL
-        urls = ['https://feed.feralfile.com/api/v1'];
+        urls = ['https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1'];
     }
     return {
         baseURLs: urls,
@@ -241,24 +242,9 @@ function getFF1DeviceConfig() {
  * @returns {boolean} returns.supportsFunctionCalling - Whether model supports function calling
  * @throws {Error} If model is not configured or doesn't support function calling
  */
-function resolveModelName(config, modelName) {
-    const selectedModel = modelName || config.defaultModel;
-    if (config.models[selectedModel]) {
-        return selectedModel;
-    }
-    const aliasMap = {
-        gpt: 'chatgpt',
-        chatgpt: 'gpt',
-    };
-    const alias = aliasMap[selectedModel];
-    if (alias && config.models[alias]) {
-        return alias;
-    }
-    return selectedModel;
-}
 function getModelConfig(modelName) {
     const config = getConfig();
-    const selectedModel = resolveModelName(config, modelName);
+    const selectedModel = modelName || config.defaultModel;
     if (!config.models[selectedModel]) {
         throw new Error(`Model "${selectedModel}" is not configured. Available models: ${Object.keys(config.models).join(', ')}`);
     }
@@ -285,7 +271,7 @@ function validateConfig(modelName) {
     const errors = [];
     try {
         const config = getConfig();
-        const selectedModel = resolveModelName(config, modelName);
+        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 };
@@ -318,13 +304,12 @@ function validateConfig(modelName) {
         // 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 placeholderPattern = /your_ed25519_private_key/i;
+            if (!placeholderPattern.test(key) && typeof key === 'string' && key.length > 0) {
                 const base64Regex = /^[A-Za-z0-9+/]+=*$/;
-                if (!base64Regex.test(key)) {
-                    errors.push('playlist.privateKey must be a valid base64-encoded ed25519 private key');
+                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');
                 }
             }
         }
@@ -377,12 +362,5 @@ async function createSampleConfig(targetPath) {
  */
 function listAvailableModels() {
     const config = getConfig();
-    const modelNames = new Set(Object.keys(config.models));
-    if (modelNames.has('gpt')) {
-        modelNames.add('chatgpt');
-    }
-    if (modelNames.has('chatgpt')) {
-        modelNames.add('gpt');
-    }
-    return Array.from(modelNames);
+    return Object.keys(config.models);
 }

package/dist/src/intent-parser/index.js

@@ -48,6 +48,7 @@ const openai_1 = __importDefault(require("openai"));
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../config");
 const utils_1 = require("./utils");
+const logger = __importStar(require("../logger"));
 // Cache for AI clients
 const clientCache = new Map();
 /**
@@ -210,7 +211,7 @@ PUBLISH INTENT (CRITICAL)
     2. If only 1 server → use it directly in playlistSettings.feedServer
     3. If 2+ servers → ask user "Which feed server?" with numbered list (e.g., "1) https://feed.feralfile.com 2) http://localhost:8787")
     4. After selection, set playlistSettings.feedServer = { baseUrl, apiKey } from selected server
-    5. Acknowledge in Settings bullets (e.g., "publish to: https://feed.feralfile.com/api/v1")
+    5. Acknowledge in Settings bullets (e.g., "publish to: https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1")
   - User can request both device display AND publishing (e.g., "send to FF1 and publish to feed") → set both deviceName and feedServer
   - Publishing happens automatically after playlist verification passes
   
@@ -369,13 +370,13 @@ const intentParserFunctionSchemas = [
         type: 'function',
         function: {
             name: 'confirm_send_playlist',
-            description: 'Confirm the playlist file path and device name for sending. This function is called after the user mentions "send" or similar phrases.',
+            description: 'Confirm the playlist file path or hosted URL and device name for sending. This function is called after the user mentions "send" or similar phrases.',
             parameters: {
                 type: 'object',
                 properties: {
                     filePath: {
                         type: 'string',
-                        description: 'Path to the playlist file (default: "./playlist.json")',
+                        description: 'Path to playlist file or playlist URL (default: "./playlist.json")',
                     },
                     deviceName: {
                         type: 'string',
@@ -483,16 +484,53 @@ function printMarkdownContent(content) {
     const lines = content.split('\n');
     for (const line of lines) {
         if (line.trim()) {
-            console.log(formatMarkdown(line));
+            logger.verbose(formatMarkdown(line));
         }
         else if (line === '') {
-            console.log();
+            logger.verbose();
         }
     }
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function extractDomains(text) {
+    if (!text) {
+        return [];
+    }
+    const matches = text.match(/[a-z0-9-]+\.(eth|tez)/gi);
+    return matches ? matches.map((match) => match.toLowerCase()) : [];
+}
+function normalizeDomainInput(address, userDomains) {
+    if (!address || userDomains.length === 0) {
+        return address;
+    }
+    const lower = address.toLowerCase();
+    if (!lower.endsWith('.eth') && !lower.endsWith('.tez')) {
+        return address;
+    }
+    const baseName = lower.replace(/\.(eth|tez)$/i, '');
+    const match = userDomains.find((domain) => domain.replace(/\.(eth|tez)$/i, '') === baseName);
+    return match || address;
+}
+function normalizeRequirementDomains(params, userDomains) {
+    if (userDomains.length === 0) {
+        return params;
+    }
+    const normalized = params.requirements.map((req) => {
+        if (req.type !== 'query_address' || typeof req.ownerAddress !== 'string') {
+            return req;
+        }
+        return {
+            ...req,
+            ownerAddress: normalizeDomainInput(req.ownerAddress, userDomains),
+        };
+    });
+    return {
+        ...params,
+        requirements: normalized,
+    };
+}
 function buildToolResponseMessages(toolCalls, responses) {
     return toolCalls
         .filter((toolCall) => toolCall.id)
@@ -514,7 +552,7 @@ async function processNonStreamingResponse(response) {
     }
     if (message.content) {
         printMarkdownContent(message.content);
-        console.log();
+        logger.verbose();
     }
     return { message };
 }
@@ -586,10 +624,10 @@ async function processStreamingResponse(stream) {
                     for (const line of lines) {
                         if (line.trim()) {
                             const formatted = formatMarkdown(line);
-                            console.log(formatted);
+                            logger.verbose(formatted);
                         }
                         else if (line === '') {
-                            console.log();
+                            logger.verbose();
                         }
                     }
                     printedUpTo = lastNewlineIndex + 1;
@@ -635,11 +673,11 @@ async function processStreamingResponse(stream) {
         const remainingText = contentBuffer.substring(printedUpTo);
         if (remainingText.trim()) {
             const formatted = formatMarkdown(remainingText);
-            console.log(formatted);
+            logger.verbose(formatted);
         }
     }
     if (contentBuffer.length > 0) {
-        console.log(); // Extra newline after AI response
+        logger.verbose(); // Extra newline after AI response
     }
     // Convert toolCallsMap to array
     toolCalls = Object.values(toolCallsMap).filter((tc) => tc.id);
@@ -664,6 +702,7 @@ async function processStreamingResponse(stream) {
  */
 async function processIntentParserRequest(userRequest, options = {}) {
     const { modelName, conversationContext } = options;
+    const userDomains = extractDomains(userRequest);
     const client = createIntentParserClient(modelName);
     const modelConfig = (0, config_1.getModelConfig)(modelName);
     const config = (0, config_1.getConfig)();
@@ -734,7 +773,7 @@ async function processIntentParserRequest(userRequest, options = {}) {
                 if (followUpMessage.tool_calls && followUpMessage.tool_calls.length > 0) {
                     const followUpToolCall = followUpMessage.tool_calls[0];
                     if (followUpToolCall.function.name === 'parse_requirements') {
-                        const params = JSON.parse(followUpToolCall.function.arguments);
+                        const params = normalizeRequirementDomains(JSON.parse(followUpToolCall.function.arguments), userDomains);
                         // Apply constraints and defaults
                         const validatedParams = (0, utils_1.applyConstraints)(params, config);
                         return {
@@ -786,7 +825,7 @@ async function processIntentParserRequest(userRequest, options = {}) {
                         if (feedFollowUpMessage.tool_calls && feedFollowUpMessage.tool_calls.length > 0) {
                             const feedToolCall = feedFollowUpMessage.tool_calls[0];
                             if (feedToolCall.function.name === 'parse_requirements') {
-                                const params = JSON.parse(feedToolCall.function.arguments);
+                                const params = normalizeRequirementDomains(JSON.parse(feedToolCall.function.arguments), userDomains);
                                 // Apply constraints and defaults
                                 const validatedParams = (0, utils_1.applyConstraints)(params, config);
                                 return {
@@ -951,7 +990,7 @@ async function processIntentParserRequest(userRequest, options = {}) {
                 if (followUpMessage.tool_calls && followUpMessage.tool_calls.length > 0) {
                     const followUpToolCall = followUpMessage.tool_calls[0];
                     if (followUpToolCall.function.name === 'parse_requirements') {
-                        const params = JSON.parse(followUpToolCall.function.arguments);
+                        const params = normalizeRequirementDomains(JSON.parse(followUpToolCall.function.arguments), userDomains);
                         // Apply constraints and defaults
                         const validatedParams = (0, utils_1.applyConstraints)(params, config);
                         return {
@@ -1014,7 +1053,7 @@ async function processIntentParserRequest(userRequest, options = {}) {
                 };
             }
             else if (toolCall.function.name === 'parse_requirements') {
-                const params = JSON.parse(toolCall.function.arguments);
+                const params = normalizeRequirementDomains(JSON.parse(toolCall.function.arguments), userDomains);
                 // Apply constraints and defaults
                 const validatedParams = (0, utils_1.applyConstraints)(params, config);
                 return {
@@ -1117,6 +1156,9 @@ async function processIntentParserRequest(userRequest, options = {}) {
             }
             else if (toolCall.function.name === 'verify_addresses') {
                 const args = JSON.parse(toolCall.function.arguments);
+                if (Array.isArray(args.addresses) && userDomains.length > 0) {
+                    args.addresses = args.addresses.map((address) => normalizeDomainInput(address, userDomains));
+                }
                 const { verifyAddresses } = await Promise.resolve().then(() => __importStar(require('../utilities/functions')));
                 const verificationResult = await verifyAddresses({ addresses: args.addresses });
                 if (!verificationResult.valid) {
@@ -1168,7 +1210,7 @@ async function processIntentParserRequest(userRequest, options = {}) {
                 if (followUpMessage.tool_calls && followUpMessage.tool_calls.length > 0) {
                     const followUpToolCall = followUpMessage.tool_calls[0];
                     if (followUpToolCall.function.name === 'parse_requirements') {
-                        const params = JSON.parse(followUpToolCall.function.arguments);
+                        const params = normalizeRequirementDomains(JSON.parse(followUpToolCall.function.arguments), userDomains);
                         // Apply constraints and defaults
                         const validatedParams = (0, utils_1.applyConstraints)(params, config);
                         return {
@@ -1221,7 +1263,7 @@ async function processIntentParserRequest(userRequest, options = {}) {
                         if (feedFollowUpMessage.tool_calls && feedFollowUpMessage.tool_calls.length > 0) {
                             const feedToolCall = feedFollowUpMessage.tool_calls[0];
                             if (feedToolCall.function.name === 'parse_requirements') {
-                                const params = JSON.parse(feedToolCall.function.arguments);
+                                const params = normalizeRequirementDomains(JSON.parse(feedToolCall.function.arguments), userDomains);
                                 // Apply constraints and defaults
                                 const validatedParams = (0, utils_1.applyConstraints)(params, config);
                                 return {

package/dist/src/intent-parser/utils.js

@@ -57,8 +57,11 @@ function applyConstraints(params, config) {
         // Set default quantity if not provided
         // Allow "all" as a string value for query_address type
         let quantity;
-        if (r.quantity === 'all' || r.quantity === null || r.quantity === undefined) {
-            quantity = r.type === 'query_address' ? 'all' : 5;
+        if (r.quantity === 'all') {
+            quantity = 'all';
+        }
+        else if (r.quantity === null || r.quantity === undefined) {
+            quantity = 5;
         }
         else if (typeof r.quantity === 'string') {
             // Try to parse string numbers

package/dist/src/logger.js

@@ -10,6 +10,7 @@ exports.setVerbose = setVerbose;
 exports.debug = debug;
 exports.info = info;
 exports.warn = warn;
+exports.verbose = verbose;
 exports.error = error;
 exports.always = always;
 const chalk_1 = __importDefault(require("chalk"));
@@ -49,6 +50,15 @@ function warn(...args) {
         console.warn(chalk_1.default.yellow('[WARN]'), ...args);
     }
 }
+/**
+ * Log message only in verbose mode (no prefix)
+ * @param {...any} args - Arguments to log
+ */
+function verbose(...args) {
+    if (isVerbose) {
+        console.log(...args);
+    }
+}
 /**
  * Log error message (always shown, but with more details in verbose mode)
  * @param {...any} args - Arguments to log

package/dist/src/utilities/ff1-compatibility.js

@@ -0,0 +1,269 @@
+"use strict";
+/**
+ * FF1 device compatibility helpers for command preflight checks.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfiguredDevice = resolveConfiguredDevice;
+exports.assertFF1CommandCompatibility = assertFF1CommandCompatibility;
+const config_1 = require("../config");
+const logger = __importStar(require("../logger"));
+const FF1_COMMAND_POLICIES = {
+    displayPlaylist: {
+        minimumVersion: '1.0.0',
+    },
+    sshAccess: {
+        minimumVersion: '1.0.9',
+    },
+};
+/**
+ * Load and validate the configured FF1 device selected by name.
+ *
+ * @param {string} [deviceName] - Optional device name, exact match required
+ * @param {Object} [options] - Optional dependency overrides
+ * @param {Function} [options.getFF1DeviceConfigFn] - Optional config loader override
+ * @returns {FF1DeviceSelectionResult} Selected device or reason for failure
+ * @throws {Error} Never throws; malformed configuration is returned as an error result
+ * @example
+ * const result = resolveConfiguredDevice('Living Room');
+ */
+function resolveConfiguredDevice(deviceName, options = {}) {
+    const getFF1DeviceConfigFn = options.getFF1DeviceConfigFn || config_1.getFF1DeviceConfig;
+    const deviceConfig = getFF1DeviceConfigFn();
+    if (!deviceConfig.devices || deviceConfig.devices.length === 0) {
+        return {
+            success: false,
+            error: 'No FF1 devices configured. Add devices to config.json under "ff1Devices"',
+        };
+    }
+    let device = deviceConfig.devices[0];
+    if (deviceName) {
+        device = deviceConfig.devices.find((item) => item.name === deviceName);
+        if (!device) {
+            const availableNames = deviceConfig.devices
+                .map((item) => item.name)
+                .filter(Boolean)
+                .join(', ');
+            return {
+                success: false,
+                error: `Device "${deviceName}" not found. Available devices: ${availableNames || 'none with names'}`,
+            };
+        }
+        logger.info(`Found device by name: ${deviceName}`);
+    }
+    else {
+        logger.info('Using first configured device');
+    }
+    if (!device.host) {
+        return {
+            success: false,
+            error: 'Invalid device configuration: must include host',
+        };
+    }
+    return {
+        success: true,
+        device,
+    };
+}
+/**
+ * Ensure the target device supports the requested FF1 command.
+ *
+ * @param {Object} device - FF1 device configuration
+ * @param {FF1Command} command - Command to execute
+ * @param {Object} [options] - Optional dependency overrides
+ * @param {Function} [options.fetchFn] - Optional fetch implementation
+ * @returns {Promise<FF1CompatibilityResult>} Compatibility result
+ * @throws {Error} Never throws; network and parsing failures produce a compatible result
+ * @example
+ * const result = await assertFF1CommandCompatibility(device, 'displayPlaylist');
+ */
+async function assertFF1CommandCompatibility(device, command, options = {}) {
+    const fetchFn = options.fetchFn || globalThis.fetch.bind(globalThis);
+    const policy = getCommandPolicy(command);
+    const versionResult = await detectFF1VersionSafely(device.host, buildVersionHeaders(device), fetchFn);
+    return resolveCompatibility(device, command, policy, versionResult);
+}
+/**
+ * Return command compatibility requirements.
+ *
+ * @param {FF1Command} command - Command to check
+ * @returns {FF1CommandPolicy} Policy metadata
+ * @example
+ * getCommandPolicy('sshAccess'); // { minimumVersion: '1.0.0' }
+ */
+function getCommandPolicy(command) {
+    return FF1_COMMAND_POLICIES[command];
+}
+/**
+ * Detect FF1 version and recover compatibility when detection fails.
+ *
+ * @param {string} host - Device host URL
+ * @param {Object} headers - Request headers
+ * @param {Function} fetchFn - Fetch implementation
+ * @returns {Promise<FF1VersionProbe | null>} Detected version metadata
+ */
+async function detectFF1VersionSafely(host, headers, fetchFn) {
+    try {
+        return await detectFF1Version(host, headers, fetchFn);
+    }
+    catch (error) {
+        logger.debug('FF1 version detection failed; continuing with command', error.message);
+        return null;
+    }
+}
+/**
+ * Resolve final compatibility decision from detected version and policy.
+ *
+ * @param {FF1Device} device - Target device
+ * @param {FF1Command} command - Command requested
+ * @param {FF1CommandPolicy} policy - Version policy
+ * @param {FF1VersionProbe | null} versionResult - Detected version probe
+ * @returns {FF1CompatibilityResult} Compatibility decision
+ */
+function resolveCompatibility(device, command, policy, versionResult) {
+    if (!versionResult) {
+        logger.warn(`Could not verify FF1 OS version for ${device.name || device.host}`);
+        return { compatible: true };
+    }
+    const normalizedVersion = normalizeVersion(versionResult.version);
+    if (!normalizedVersion) {
+        return {
+            compatible: true,
+            version: versionResult.version,
+        };
+    }
+    if (compareVersions(normalizedVersion, policy.minimumVersion) < 0) {
+        return {
+            compatible: false,
+            version: normalizedVersion,
+            error: `Unsupported FF1 OS ${normalizedVersion} for ${command}. FF1 OS must be ${policy.minimumVersion} or newer.`,
+        };
+    }
+    return {
+        compatible: true,
+        version: normalizedVersion,
+    };
+}
+/**
+ * Detect FF1 OS version via POST /api/cast with getDeviceStatus command.
+ *
+ * Reads `message.installedVersion` from the device status response.
+ *
+ * @param {string} host - Device host URL
+ * @param {Record<string, string>} headers - Request headers (e.g. API-KEY)
+ * @param {FetchFunction} fetchFn - Fetch implementation
+ * @returns {Promise<FF1VersionProbe | null>} Version probe or null if unavailable
+ * @example
+ * const probe = await detectFF1Version('http://ff1.local', {}, fetch);
+ */
+async function detectFF1Version(host, headers, fetchFn) {
+    try {
+        const response = await fetchFn(`${host}/api/cast`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ command: 'getDeviceStatus', request: {} }),
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = (await response.json());
+        const version = data?.message?.installedVersion;
+        if (!version) {
+            return null;
+        }
+        return { version };
+    }
+    catch (_error) {
+        return null;
+    }
+}
+/**
+ * Build headers shared by cast requests.
+ *
+ * @param {FF1Device} device - Target device
+ * @returns {Record<string, string>} Headers map
+ * @example
+ * const headers = buildVersionHeaders(device);
+ */
+function buildVersionHeaders(device) {
+    const headers = {};
+    if (device.apiKey) {
+        headers['API-KEY'] = device.apiKey;
+    }
+    return headers;
+}
+/**
+ * Parse and normalize a version string to x.y.z format.
+ *
+ * @param {string} version - Raw version string
+ * @returns {string | null} Normalized semver-like version
+ * @example
+ * normalizeVersion('v1.2') // '1.2.0'
+ */
+function normalizeVersion(version) {
+    const raw = version.trim();
+    const match = raw.match(/(?:v)?(\d+)\.(\d+)(?:\.(\d+))?/);
+    if (!match) {
+        return null;
+    }
+    const major = match[1];
+    const minor = match[2];
+    const patch = match[3] || '0';
+    return `${major}.${minor}.${patch}`;
+}
+/**
+ * Compare two semantic versions in x.y.z format.
+ *
+ * @param {string} left - First version
+ * @param {string} right - Second version
+ * @returns {number} 1 if left > right, -1 if left < right, 0 if equal
+ * @example
+ * compareVersions('1.2.1', '1.2.0'); // 1
+ */
+function compareVersions(left, right) {
+    const leftParts = left.split('.').map((value) => Number.parseInt(value, 10));
+    const rightParts = right.split('.').map((value) => Number.parseInt(value, 10));
+    for (let i = 0; i < 3; i++) {
+        const leftPart = leftParts[i] || 0;
+        const rightPart = rightParts[i] || 0;
+        if (leftPart > rightPart) {
+            return 1;
+        }
+        if (leftPart < rightPart) {
+            return -1;
+        }
+    }
+    return 0;
+}

package/dist/src/utilities/ff1-device.js

@@ -38,8 +38,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendPlaylistToDevice = sendPlaylistToDevice;
-const config_1 = require("../config");
 const logger = __importStar(require("../logger"));
+const ff1_compatibility_1 = require("./ff1-compatibility");
 /**
  * Send a DP1 playlist to an FF1 device using the cast API
  *
@@ -80,38 +80,20 @@ async function sendPlaylistToDevice({ playlist, deviceName, }) {
                 error: 'Invalid playlist: must provide a valid DP1 playlist object',
             };
         }
-        // Get device configuration
-        const deviceConfig = (0, config_1.getFF1DeviceConfig)();
-        if (!deviceConfig.devices || deviceConfig.devices.length === 0) {
+        const resolved = (0, ff1_compatibility_1.resolveConfiguredDevice)(deviceName);
+        if (!resolved.success || !resolved.device) {
             return {
                 success: false,
-                error: 'No FF1 devices configured. Please add devices to config.json under "ff1Devices"',
+                error: resolved.error || 'FF1 device is not configured correctly',
             };
         }
-        // Find device by name if provided, otherwise use first device
-        let device;
-        if (deviceName) {
-            device = deviceConfig.devices.find((d) => d.name === deviceName);
-            if (!device) {
-                const availableNames = deviceConfig.devices
-                    .map((d) => d.name)
-                    .filter(Boolean)
-                    .join(', ');
-                return {
-                    success: false,
-                    error: `Device "${deviceName}" not found. Available devices: ${availableNames || 'none with names'}`,
-                };
-            }
-            logger.info(`Found device by name: ${deviceName}`);
-        }
-        else {
-            device = deviceConfig.devices[0];
-            logger.info('Using first configured device');
-        }
-        if (!device.host) {
+        const device = resolved.device;
+        const compatibility = await (0, ff1_compatibility_1.assertFF1CommandCompatibility)(device, 'displayPlaylist');
+        if (!compatibility.compatible) {
             return {
                 success: false,
-                error: 'Invalid device configuration: must include host',
+                error: compatibility.error || 'FF1 OS does not support playlist casting',
+                details: compatibility.version ? `Detected version ${compatibility.version}` : undefined,
             };
         }
         logger.info(`Sending playlist to FF1 device: ${device.host}`);