ff1-cli 1.0.0

package/dist/src/utilities/playlist-send.js

@@ -0,0 +1,241 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.confirmPlaylistForSending = confirmPlaylistForSending;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+/**
+ * Get available FF1 devices from config
+ *
+ * @returns {Promise<Array>} Array of device objects
+ */
+async function getAvailableDevices() {
+    try {
+        const configModule = (await Promise.resolve().then(() => __importStar(require('../config'))));
+        const getFF1DeviceConfig = configModule.getFF1DeviceConfig ||
+            (configModule.default && configModule.default.getFF1DeviceConfig) ||
+            configModule.default;
+        if (typeof getFF1DeviceConfig !== 'function') {
+            return [];
+        }
+        const deviceConfig = getFF1DeviceConfig();
+        if (deviceConfig.devices && Array.isArray(deviceConfig.devices)) {
+            return deviceConfig.devices
+                .filter((d) => d && d.host)
+                .map((d) => ({
+                name: d.name || d.host,
+                host: d.host,
+            }));
+        }
+    }
+    catch (error) {
+        if (process.env.DEBUG) {
+            console.log(chalk_1.default.gray(`[DEBUG] Error loading devices: ${error.message}`));
+        }
+        // Silently fail if config can't be loaded
+    }
+    return [];
+}
+/**
+ * Confirm playlist file path and validate the playlist
+ *
+ * Reads the playlist file, validates it against DP-1 spec,
+ * and returns confirmation result for user review.
+ *
+ * @param {string} filePath - Path to playlist file
+ * @param {string} [deviceName] - Device name (optional)
+ * @returns {Promise<PlaylistSendConfirmation>} Validation result
+ */
+async function confirmPlaylistForSending(filePath, deviceName) {
+    const defaultPath = './playlist.json';
+    const resolvedPath = filePath || defaultPath;
+    // Convert string "null" to undefined (in case model passes it literally)
+    const actualDeviceName = deviceName === 'null' || deviceName === '' ? undefined : deviceName;
+    if (process.env.DEBUG) {
+        console.error(chalk_1.default.gray(`[DEBUG] confirmPlaylistForSending called with: filePath="${filePath}", deviceName="${deviceName}" -> "${actualDeviceName}"`));
+    }
+    try {
+        // Check if file exists
+        console.log(chalk_1.default.cyan(`Checking playlist file: ${resolvedPath}...`));
+        let _fileExists = false;
+        let playlist;
+        try {
+            const content = await fs_1.promises.readFile(resolvedPath, 'utf-8');
+            playlist = JSON.parse(content);
+            _fileExists = true;
+            console.log(chalk_1.default.green('✓ File found'));
+        }
+        catch (error) {
+            const errorMsg = error.message;
+            if (errorMsg.includes('ENOENT') || errorMsg.includes('no such file')) {
+                console.log(chalk_1.default.red(`✗ File not found: ${resolvedPath}`));
+                return {
+                    success: false,
+                    filePath: resolvedPath,
+                    fileExists: false,
+                    playlistValid: false,
+                    error: `Playlist file not found at ${resolvedPath}`,
+                    message: `Could not find playlist file. Try:\n  • Run a playlist build first\n  • Check the file path is correct\n  • Use "send ./path/to/playlist.json"`,
+                };
+            }
+            throw error;
+        }
+        if (!playlist) {
+            return {
+                success: false,
+                filePath: resolvedPath,
+                fileExists: true,
+                playlistValid: false,
+                error: 'Playlist file is empty',
+            };
+        }
+        // Validate playlist structure
+        console.log(chalk_1.default.cyan('Validating playlist...'));
+        // Dynamic import to avoid circular dependency
+        const { verifyPlaylist } = await Promise.resolve().then(() => __importStar(require('./playlist-verifier')));
+        const verifyResult = verifyPlaylist(playlist);
+        if (!verifyResult.valid) {
+            console.log(chalk_1.default.red('✗ Playlist validation failed'));
+            const detailLines = verifyResult.details?.map((d) => `  • ${d.path}: ${d.message}`).join('\n') ||
+                verifyResult.error;
+            const detailPaths = verifyResult.details?.map((d) => d.path) || [];
+            const hints = [];
+            if (detailPaths.some((path) => path.includes('signature'))) {
+                hints.push('Add `playlist.privateKey` (or `PLAYLIST_PRIVATE_KEY`) and rebuild the playlist to include a signature.');
+            }
+            if (detailPaths.some((path) => path.includes('defaults.display.margin'))) {
+                hints.push('Rebuild the playlist with the latest CLI defaults (margin must be numeric).');
+            }
+            const hintText = hints.length > 0 ? `\n\nHint:\n${hints.map((h) => `  • ${h}`).join('\n')}` : '';
+            return {
+                success: false,
+                filePath: resolvedPath,
+                fileExists: true,
+                playlistValid: false,
+                playlist,
+                deviceName: actualDeviceName,
+                error: `Playlist is invalid: ${verifyResult.error}`,
+                message: `This playlist doesn't match DP-1 specification.\n\nErrors:\n${detailLines}${hintText}`,
+            };
+        }
+        console.log(chalk_1.default.green('✓ Playlist is valid'));
+        // Display confirmation details
+        const itemCount = playlist.items?.length || 0;
+        const title = playlist.title || 'Untitled';
+        // Handle device selection
+        let selectedDevice = actualDeviceName;
+        let needsDeviceSelection = false;
+        let availableDevices = [];
+        if (!selectedDevice) {
+            // Get available devices
+            availableDevices = await getAvailableDevices();
+            if (process.env.DEBUG) {
+                console.error(chalk_1.default.gray(`[DEBUG] selectedDevice is null/undefined`));
+                console.error(chalk_1.default.gray(`[DEBUG] Available devices found: ${availableDevices.length}`));
+                availableDevices.forEach((d) => {
+                    console.error(chalk_1.default.gray(`[DEBUG] Device: ${d.name} (${d.host})`));
+                });
+            }
+            if (availableDevices.length === 0) {
+                return {
+                    success: false,
+                    filePath: resolvedPath,
+                    fileExists: true,
+                    playlistValid: true,
+                    playlist,
+                    error: 'No FF1 devices configured',
+                    message: `No FF1 devices found in your configuration.\n\nPlease add devices to your config.json:\n{\n  "devices": [{\n    "name": "Living Room",\n    "host": "192.168.1.100"\n  }]\n}`,
+                };
+            }
+            else if (availableDevices.length === 1) {
+                // Auto-select single device
+                selectedDevice = availableDevices[0].name || availableDevices[0].host;
+                console.log(chalk_1.default.cyan(`Auto-selecting device: ${selectedDevice}`));
+            }
+            else {
+                // Multiple devices - need user to choose
+                needsDeviceSelection = true;
+            }
+        }
+        console.log();
+        console.log(chalk_1.default.bold('Playlist Summary:'));
+        console.log(chalk_1.default.gray(`  Title: ${title}`));
+        console.log(chalk_1.default.gray(`  Items: ${itemCount}`));
+        if (selectedDevice) {
+            console.log(chalk_1.default.gray(`  Device: ${selectedDevice}`));
+        }
+        else if (availableDevices.length > 1) {
+            console.log(chalk_1.default.gray(`  Device: (to be selected)`));
+        }
+        console.log();
+        // If multiple devices, return needsDeviceSelection flag
+        if (needsDeviceSelection) {
+            return {
+                success: false,
+                filePath: resolvedPath,
+                fileExists: true,
+                playlistValid: true,
+                playlist,
+                needsDeviceSelection: true,
+                availableDevices,
+                error: 'Multiple devices available - please choose one',
+                message: `Which device would you like to display on?\n\nAvailable devices:\n${availableDevices.map((d, i) => `  ${i + 1}. ${d.name || d.host}`).join('\n')}\n\nSay: "send to [device name]" or "send to device 1"`,
+            };
+        }
+        return {
+            success: true,
+            filePath: resolvedPath,
+            fileExists: true,
+            playlistValid: true,
+            playlist,
+            deviceName: selectedDevice,
+            message: `Ready to send "${title}" (${itemCount} items) to ${selectedDevice}!`,
+        };
+    }
+    catch (error) {
+        const errorMsg = error.message;
+        console.log(chalk_1.default.red(`✗ Error: ${errorMsg}`));
+        return {
+            success: false,
+            filePath: resolvedPath,
+            fileExists: false,
+            playlistValid: false,
+            error: errorMsg,
+        };
+    }
+}

package/dist/src/utilities/playlist-signer.js

@@ -0,0 +1,171 @@
+/**
+ * Playlist Signing Utility
+ * Uses dp1-js library for DP-1 specification-compliant playlist signing
+ */
+const { signDP1Playlist, verifyPlaylistSignature } = require('dp1-js');
+const { getPlaylistConfig } = require('../config');
+/**
+ * Convert base64-encoded key to Uint8Array (or hex string if needed)
+ *
+ * @param {string} base64Key - Ed25519 private key in base64 format
+ * @returns {Uint8Array} Private key as Uint8Array
+ */
+function base64ToUint8Array(base64Key) {
+    const buffer = Buffer.from(base64Key, 'base64');
+    return new Uint8Array(buffer);
+}
+/**
+ * Convert hex string to Uint8Array
+ *
+ * @param {string} hexKey - Ed25519 public key in hex format
+ * @returns {Uint8Array} Public key as Uint8Array
+ */
+function hexToUint8Array(hexKey) {
+    const cleanHex = hexKey.replace(/^0x/, '');
+    const buffer = Buffer.from(cleanHex, 'hex');
+    return new Uint8Array(buffer);
+}
+/**
+ * Check if a string is valid hex (with or without 0x prefix)
+ *
+ * @param {string} str - String to test
+ * @returns {boolean} True if string is valid hex
+ */
+function isHexString(str) {
+    const cleanHex = str.replace(/^0x/, '');
+    return /^[0-9a-fA-F]+$/.test(cleanHex) && cleanHex.length % 2 === 0;
+}
+/**
+ * Sign a playlist using ed25519 as per DP-1 specification
+ * Uses dp1-js library for standards-compliant signing
+ * Accepts private key in hex (with or without 0x prefix) or base64 format
+ *
+ * @param {Object} playlist - Playlist object without signature
+ * @param {string} [privateKeyBase64] - Ed25519 private key in hex or base64 format (optional, uses config if not provided)
+ * @returns {Promise<string>} Signature in format "ed25519:0x{hex}"
+ * @throws {Error} If private key is invalid or signing fails
+ * @example
+ * const signature = await signPlaylist(playlist, privateKeyHexOrBase64);
+ * // Returns: "ed25519:0x1234abcd..."
+ */
+async function signPlaylist(playlist, privateKeyBase64) {
+    // Get private key from config if not provided
+    let privateKey = privateKeyBase64;
+    if (!privateKey) {
+        const config = getPlaylistConfig();
+        privateKey = config.privateKey;
+    }
+    if (!privateKey) {
+        throw new Error('Private key is required for signing');
+    }
+    try {
+        // Remove signature field if it exists (for re-signing)
+        const playlistToSign = { ...playlist };
+        delete playlistToSign.signature;
+        // Try hex first (with or without 0x prefix), then fall back to base64
+        let keyInput;
+        if (isHexString(privateKey)) {
+            // It's hex - ensure it has 0x prefix for dp1-js
+            keyInput = privateKey.startsWith('0x') ? privateKey : '0x' + privateKey;
+        }
+        else {
+            // Fall back to base64
+            const keyBytes = base64ToUint8Array(privateKey);
+            keyInput = '0x' + Buffer.from(keyBytes).toString('hex');
+        }
+        // Sign using dp1-js library
+        const signature = await signDP1Playlist(playlistToSign, keyInput);
+        return signature;
+    }
+    catch (error) {
+        throw new Error(`Failed to sign playlist: ${error.message}`);
+    }
+}
+/**
+ * Verify a playlist's ed25519 signature
+ *
+ * @param {Object} playlist - Playlist object with signature field
+ * @param {string} publicKeyHex - Ed25519 public key in hex format (with or without 0x prefix)
+ * @returns {Promise<boolean>} True if signature is valid, false otherwise
+ * @throws {Error} If verification process fails
+ * @example
+ * const isValid = await verifyPlaylist(signedPlaylist, publicKeyHex);
+ * if (isValid) {
+ *   console.log('Signature is valid');
+ * }
+ */
+async function verifyPlaylist(playlist, publicKeyHex) {
+    if (!playlist.signature) {
+        throw new Error('Playlist does not have a signature');
+    }
+    if (!publicKeyHex) {
+        throw new Error('Public key is required for verification');
+    }
+    try {
+        // Convert hex public key to Uint8Array
+        const publicKeyBytes = hexToUint8Array(publicKeyHex);
+        // Verify using dp1-js library
+        const isValid = await verifyPlaylistSignature(playlist, publicKeyBytes);
+        return isValid;
+    }
+    catch (error) {
+        throw new Error(`Failed to verify playlist signature: ${error.message}`);
+    }
+}
+/**
+ * Sign a playlist file
+ * Reads playlist from file, signs it, and writes back
+ *
+ * @param {string} playlistPath - Path to playlist JSON file
+ * @param {string} [privateKeyBase64] - Ed25519 private key in hex or base64 format (optional, uses config if not provided)
+ * @param {string} [outputPath] - Output path (optional, overwrites input if not provided)
+ * @returns {Promise<Object>} Result with signed playlist
+ * @returns {boolean} returns.success - Whether signing succeeded
+ * @returns {Object} [returns.playlist] - Signed playlist object
+ * @returns {string} [returns.error] - Error message if failed
+ * @example
+ * const result = await signPlaylistFile('playlist.json');
+ * if (result.success) {
+ *   console.log('Playlist signed:', result.playlist);
+ * }
+ */
+async function signPlaylistFile(playlistPath, privateKeyBase64, outputPath) {
+    const fs = require('fs');
+    const path = require('path');
+    try {
+        // Read playlist file
+        if (!fs.existsSync(playlistPath)) {
+            throw new Error(`Playlist file not found: ${playlistPath}`);
+        }
+        const playlistContent = fs.readFileSync(playlistPath, 'utf-8');
+        const playlist = JSON.parse(playlistContent);
+        // Sign playlist
+        const signature = await signPlaylist(playlist, privateKeyBase64);
+        // Add signature to playlist
+        const signedPlaylist = {
+            ...playlist,
+            signature,
+        };
+        // Write to output file
+        const output = outputPath || playlistPath;
+        fs.writeFileSync(output, JSON.stringify(signedPlaylist, null, 2), 'utf-8');
+        console.log(`✓ Playlist signed and saved to: ${path.resolve(output)}`);
+        return {
+            success: true,
+            playlist: signedPlaylist,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}
+module.exports = {
+    signPlaylist,
+    verifyPlaylist,
+    signPlaylistFile,
+    base64ToUint8Array,
+    hexToUint8Array,
+};

package/dist/src/utilities/playlist-verifier.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Playlist Verification Utility
+ * Uses dp1-js library for DP-1 specification-compliant playlist validation
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPlaylist = verifyPlaylist;
+exports.verifyPlaylistFile = verifyPlaylistFile;
+exports.printVerificationResult = printVerificationResult;
+const dp1_js_1 = require("dp1-js");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+/**
+ * Verify playlist structure and integrity
+ *
+ * Validates playlist against DP-1 specification using dp1-js parser.
+ * Returns detailed validation errors if playlist is invalid.
+ *
+ * @param {Object} playlist - Playlist object to verify
+ * @returns {Object} Verification result
+ * @returns {boolean} returns.valid - Whether playlist is valid
+ * @returns {string} [returns.error] - Error message if invalid
+ * @returns {Array<Object>} [returns.details] - Detailed validation errors
+ * @example
+ * const result = verifyPlaylist(playlist);
+ * if (result.valid) {
+ *   console.log('Playlist is valid');
+ * } else {
+ *   console.error('Invalid:', result.error);
+ * }
+ */
+function verifyPlaylist(playlist) {
+    try {
+        // Use dp1-js parseDP1Playlist for validation
+        const result = (0, dp1_js_1.parseDP1Playlist)(playlist);
+        if (result.error) {
+            return {
+                valid: false,
+                error: result.error.message,
+                details: result.error.details || [],
+            };
+        }
+        // Validation successful
+        return {
+            valid: true,
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            error: `Verification failed: ${error.message}`,
+        };
+    }
+}
+/**
+ * Verify playlist file
+ *
+ * Reads playlist from file and validates structure.
+ *
+ * @param {string} playlistPath - Path to playlist JSON file
+ * @returns {Promise<Object>} Verification result
+ * @returns {boolean} returns.valid - Whether playlist is valid
+ * @returns {Object} [returns.playlist] - Validated playlist object
+ * @returns {string} [returns.error] - Error message if invalid
+ * @returns {Array<Object>} [returns.details] - Detailed validation errors
+ * @example
+ * const result = await verifyPlaylistFile('playlist.json');
+ * if (result.valid) {
+ *   console.log('Playlist is valid');
+ * }
+ */
+async function verifyPlaylistFile(playlistPath) {
+    try {
+        // Check if file exists
+        try {
+            await fs_1.promises.access(playlistPath);
+        }
+        catch {
+            return {
+                valid: false,
+                error: `Playlist file not found: ${playlistPath}`,
+            };
+        }
+        // Read and parse playlist file
+        const playlistContent = await fs_1.promises.readFile(playlistPath, 'utf-8');
+        let playlistData;
+        try {
+            playlistData = JSON.parse(playlistContent);
+        }
+        catch (parseError) {
+            return {
+                valid: false,
+                error: `Invalid JSON: ${parseError.message}`,
+            };
+        }
+        // Verify using dp1-js
+        const result = verifyPlaylist(playlistData);
+        if (result.valid) {
+            return {
+                valid: true,
+                playlist: playlistData,
+            };
+        }
+        return {
+            valid: false,
+            error: result.error,
+            details: result.details,
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            error: `Failed to verify playlist file: ${error.message}`,
+        };
+    }
+}
+/**
+ * Print verification results to console
+ *
+ * @param {Object} result - Verification result
+ * @param {string} [filename] - Optional filename to include in output
+ */
+function printVerificationResult(result, filename) {
+    if (result.valid) {
+        console.log(chalk_1.default.green('\n✅ Playlist is valid!'));
+        if (filename) {
+            console.log(chalk_1.default.gray(`   File: ${filename}`));
+        }
+        if (result.playlist) {
+            console.log(chalk_1.default.gray(`   Title: ${result.playlist.title}`));
+            console.log(chalk_1.default.gray(`   Items: ${result.playlist.items?.length || 0}`));
+            console.log(chalk_1.default.gray(`   DP Version: ${result.playlist.dpVersion}`));
+            if (result.playlist.signature && typeof result.playlist.signature === 'string') {
+                console.log(chalk_1.default.gray(`   Signature: ${result.playlist.signature.substring(0, 30)}...`));
+            }
+        }
+        console.log();
+    }
+    else {
+        console.log(chalk_1.default.red('\n❌ Playlist validation failed!'));
+        if (filename) {
+            console.log(chalk_1.default.gray(`   File: ${filename}`));
+        }
+        console.log(chalk_1.default.red(`   Error: ${result.error}`));
+        if (result.details && result.details.length > 0) {
+            console.log(chalk_1.default.yellow('\n   Validation errors:'));
+            result.details.forEach((detail) => {
+                console.log(chalk_1.default.yellow(`     • ${detail.path}: ${detail.message}`));
+            });
+        }
+        console.log();
+    }
+}

package/dist/src/utils.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.savePlaylist = savePlaylist;
+exports.loadPlaylist = loadPlaylist;
+exports.formatFileSize = formatFileSize;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+/**
+ * Save playlist to a JSON file
+ * @param {Object} playlist - The playlist object
+ * @param {string} filename - Output filename
+ * @returns {Promise<string>} Path to the saved file
+ */
+async function savePlaylist(playlist, filename) {
+    const outputPath = path_1.default.resolve(process.cwd(), filename);
+    // Ensure the playlist is properly formatted
+    const formattedPlaylist = JSON.stringify(playlist, null, 2);
+    await fs_1.promises.writeFile(outputPath, formattedPlaylist, 'utf-8');
+    return outputPath;
+}
+/**
+ * Load playlist from a JSON file
+ * @param {string} filename - Input filename
+ * @returns {Promise<Object>} The playlist object
+ */
+async function loadPlaylist(filename) {
+    const filePath = path_1.default.resolve(process.cwd(), filename);
+    const content = await fs_1.promises.readFile(filePath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Format file size in human-readable format
+ * @param {number} bytes - Size in bytes
+ * @returns {string} Formatted size
+ */
+function formatFileSize(bytes) {
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+    }
+    return `${size.toFixed(2)} ${units[unitIndex]}`;
+}