@feralfile/cli 1.1.1

package/dist/src/commands/device.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const device_lookup_1 = require("../utilities/device-lookup");
+const device_normalize_1 = require("../utilities/device-normalize");
+const device_upsert_1 = require("../utilities/device-upsert");
+const device_default_1 = require("../utilities/device-default");
+const config_files_1 = require("./helpers/config-files");
+const device_discovery_1 = require("./helpers/device-discovery");
+const prompt_1 = require("./helpers/prompt");
+const deviceCommand = new commander_1.Command('device').description('Manage configured FF1 devices');
+exports.deviceCommand = deviceCommand;
+deviceCommand
+    .command('list')
+    .description('List all configured FF1 devices')
+    .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 devices = config.ff1Devices?.devices || [];
+        if (devices.length === 0) {
+            console.log(chalk_1.default.yellow('\nNo devices configured'));
+            console.log(chalk_1.default.dim('Run: ff1 device add'));
+            console.log();
+            return;
+        }
+        console.log(chalk_1.default.blue(`\nFF1 Devices (${devices.length})\n`));
+        devices.forEach((device, index) => {
+            const isFirst = index === 0;
+            const marker = isFirst ? chalk_1.default.green('→') : ' ';
+            const nameLabel = device.name || 'unnamed';
+            console.log(`${marker} ${chalk_1.default.bold(nameLabel)}`);
+            console.log(`    Host: ${chalk_1.default.dim(device.host)}`);
+            if (device.apiKey) {
+                console.log(`    API key: ${chalk_1.default.green('Set')}`);
+            }
+            if (device.topicID) {
+                console.log(`    Topic: ${chalk_1.default.dim(device.topicID)}`);
+            }
+            if (isFirst) {
+                console.log(`    ${chalk_1.default.dim('(default)')}`);
+            }
+            console.log();
+        });
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError:'), error.message);
+        process.exit(1);
+    }
+});
+deviceCommand
+    .command('add')
+    .description('Add a new FF1 device (with mDNS discovery)')
+    .option('--host <host>', 'Device host (skip discovery)')
+    .option('--name <name>', 'Device name')
+    .action(async (options) => {
+    // Lazy prompt: non-interactive paths (--host + --name) must never block on stdin.
+    let prompt = null;
+    const ask = async (question) => {
+        if (!prompt) {
+            prompt = (0, prompt_1.createPrompt)();
+        }
+        return prompt.ask(question);
+    };
+    const closePrompt = () => {
+        if (prompt) {
+            prompt.close();
+        }
+    };
+    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 existingDevices = config.ff1Devices?.devices || [];
+        let hostValue = '';
+        let discoveredName = '';
+        let discoveredId;
+        let discoveredAddresses;
+        if (options.host) {
+            hostValue = (0, device_normalize_1.normalizeDeviceHost)(options.host);
+        }
+        else {
+            console.log(chalk_1.default.blue('\nDiscover FF1 devices...\n'));
+            const selection = await (0, device_discovery_1.discoverAndSelectDevice)(ask, existingDevices);
+            hostValue = selection.hostValue;
+            discoveredName = selection.discoveredName;
+            discoveredId = selection.discoveredId;
+            discoveredAddresses = selection.discoveredAddresses;
+            if (!hostValue) {
+                console.log(chalk_1.default.dim('\nNo device added.'));
+                closePrompt();
+                return;
+            }
+        }
+        // Find any existing entry that represents this device, including cases
+        // where the host URL changed (IP ↔ .local) since the device was last added.
+        const existingEntry = (0, device_lookup_1.findExistingDeviceEntry)(existingDevices, hostValue, discoveredName, discoveredId, discoveredAddresses);
+        const existingIndex = existingEntry
+            ? existingDevices.findIndex((d) => d === existingEntry)
+            : -1;
+        if (existingIndex !== -1) {
+            if (options.host && options.name) {
+                // Non-interactive: auto-overwrite when both flags are supplied.
+                console.log(chalk_1.default.yellow(`\nUpdating existing device: ${existingDevices[existingIndex].name || existingDevices[existingIndex].host}`));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`\nDevice already configured: ${existingDevices[existingIndex].name || existingDevices[existingIndex].host}`));
+                const overwrite = await (0, prompt_1.promptYesNo)(ask, 'Update this device?', false);
+                if (!overwrite) {
+                    console.log(chalk_1.default.dim('No changes made.'));
+                    closePrompt();
+                    return;
+                }
+            }
+        }
+        // Preserve the stored friendly name as the default so a blank prompt never
+        // clobbers a curated label (even after a host-URL change).
+        const existingName = existingEntry?.name || '';
+        let deviceName;
+        if (options.name) {
+            deviceName = options.name;
+        }
+        else {
+            const defaultName = existingName || discoveredName || '';
+            const namePrompt = defaultName
+                ? `Device name (kitchen, office, etc.) [${defaultName}]: `
+                : 'Device name (kitchen, office, etc.): ';
+            const nameAnswer = await ask(namePrompt);
+            deviceName = nameAnswer || defaultName || 'ff1';
+        }
+        // Reject a name that is already used by a DIFFERENT device (not the one being updated).
+        // Only applies when existingIndex !== -1: we know exactly which row to update, so a
+        // same-name entry at a different index is provably a different device. When
+        // existingIndex === -1 (no confirmed match, e.g. manual IP → .local migration),
+        // a same-name entry is the upsertDevice case-3 migration path — blocking it would
+        // prevent the user from retaining their existing device name during host migration.
+        const nameConflict = existingIndex !== -1
+            ? existingDevices.find((d, i) => d.name === deviceName && i !== existingIndex)
+            : undefined;
+        if (nameConflict) {
+            if (options.name) {
+                console.error(chalk_1.default.red(`\nError: device name "${deviceName}" is already used by another device (${nameConflict.host}).`));
+                console.error(chalk_1.default.dim('Use a different name or run "ff1 device remove" first.'));
+                closePrompt();
+                process.exit(1);
+            }
+            console.log(chalk_1.default.yellow(`"${deviceName}" is already used by another device. Please choose a different name.`));
+            const retryAnswer = await ask('Device name: ');
+            deviceName = retryAnswer || 'ff1';
+            const retryConflict = existingIndex !== -1
+                ? existingDevices.find((d, i) => d.name === deviceName && i !== existingIndex)
+                : undefined;
+            if (retryConflict) {
+                console.error(chalk_1.default.red(`\nName "${deviceName}" is also taken. No changes made.`));
+                closePrompt();
+                return;
+            }
+        }
+        const result = (0, device_upsert_1.upsertDevice)(existingDevices, { name: deviceName, host: hostValue, id: discoveredId, addresses: discoveredAddresses }, existingIndex !== -1 ? existingIndex : undefined);
+        console.log(chalk_1.default.green(`\n${result.updated ? 'Updated' : 'Added'} device: ${deviceName}`));
+        config.ff1Devices = { devices: result.devices };
+        await fs_1.promises.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+        console.log(chalk_1.default.dim(`Total devices: ${result.devices.length}\n`));
+        closePrompt();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError:'), error.message);
+        closePrompt();
+        process.exit(1);
+    }
+});
+deviceCommand
+    .command('remove')
+    .description('Remove a configured FF1 device')
+    .argument('<name>', 'Device name to remove')
+    .action(async (name) => {
+    try {
+        const configPath = await (0, config_files_1.resolveExistingConfigPath)();
+        if (!configPath) {
+            console.log(chalk_1.default.red('config.json not found'));
+            process.exit(1);
+        }
+        const config = await (0, config_files_1.readConfigFile)(configPath);
+        const existingDevices = config.ff1Devices?.devices || [];
+        // Match by name (case-insensitive) or by host URL so unnamed legacy/manual
+        // entries (stored without a name field) can still be targeted and removed.
+        const normalizedArg = name.toLowerCase();
+        let normalizedArgHost = '';
+        try {
+            normalizedArgHost = (0, device_normalize_1.normalizeDeviceHost)(name).toLowerCase();
+        }
+        catch {
+            // not a valid URL — host matching will not apply
+        }
+        const deviceIndex = existingDevices.findIndex((d) => (d.name && d.name.toLowerCase() === normalizedArg) ||
+            (d.host && d.host.toLowerCase() === normalizedArg) ||
+            (normalizedArgHost &&
+                d.host &&
+                (0, device_normalize_1.normalizeDeviceHost)(d.host).toLowerCase() === normalizedArgHost));
+        if (deviceIndex === -1) {
+            console.error(chalk_1.default.red(`\nDevice "${name}" not found`));
+            if (existingDevices.length > 0) {
+                const names = existingDevices.map((d) => d.name || d.host).join(', ');
+                console.log(chalk_1.default.dim(`Available devices: ${names}`));
+            }
+            process.exit(1);
+        }
+        const removed = existingDevices[deviceIndex];
+        const updatedDevices = existingDevices.filter((_, i) => i !== deviceIndex);
+        config.ff1Devices = { devices: updatedDevices };
+        await fs_1.promises.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+        console.log(chalk_1.default.green(`\nRemoved device: ${removed.name || removed.host}`));
+        console.log(chalk_1.default.dim(`Remaining devices: ${updatedDevices.length}\n`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError:'), error.message);
+        process.exit(1);
+    }
+});
+deviceCommand
+    .command('default')
+    .description('Set the default FF1 device (reorders so this device is used when -d is omitted)')
+    .argument('<name>', 'Device name or host to promote to default')
+    .action(async (name) => {
+    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 existingDevices = config.ff1Devices?.devices || [];
+        if (existingDevices.length === 0) {
+            console.log(chalk_1.default.yellow('\nNo devices configured'));
+            console.log(chalk_1.default.dim('Run: ff1 device add\n'));
+            process.exit(1);
+        }
+        let result;
+        try {
+            result = (0, device_default_1.promoteDeviceToDefault)(existingDevices, name);
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`\n${error.message}`));
+            const names = existingDevices.map((d) => d.name || d.host).join(', ');
+            console.log(chalk_1.default.dim(`Available devices: ${names}\n`));
+            process.exit(1);
+        }
+        const label = result.promoted.name || result.promoted.host;
+        if (result.alreadyDefault) {
+            console.log(chalk_1.default.dim(`\n"${label}" is already the default.\n`));
+            return;
+        }
+        config.ff1Devices = { devices: result.devices };
+        await fs_1.promises.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+        console.log(chalk_1.default.green(`\nDefault device: ${label}`));
+        console.log(chalk_1.default.dim('Other commands now target this device when -d is omitted.\n'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError:'), error.message);
+        process.exit(1);
+    }
+});

package/dist/src/commands/helpers/config-files.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMissingConfigValue = isMissingConfigValue;
+exports.readConfigFile = readConfigFile;
+exports.resolveExistingConfigPath = resolveExistingConfigPath;
+exports.ensureConfigFile = ensureConfigFile;
+const fs_1 = require("fs");
+const config_1 = require("../../config");
+// Treat any value containing the YOUR_/your_ placeholder pattern as missing,
+// since createSampleConfig writes those literal placeholders into new files
+// and we should not let the user proceed with an unfilled value.
+const placeholderPattern = /YOUR_|your_/;
+/**
+ * Whether a config value is unset or still holds a sample placeholder.
+ */
+function isMissingConfigValue(value) {
+    if (!value) {
+        return true;
+    }
+    return placeholderPattern.test(value);
+}
+/**
+ * Read and parse a config.json file at the given path.
+ */
+async function readConfigFile(configPath) {
+    const file = await fs_1.promises.readFile(configPath, 'utf-8');
+    return JSON.parse(file);
+}
+/**
+ * Locate an existing config.json. Local (`./config.json`) wins over user
+ * (`~/.config/ff1/config.json`). Returns null when neither exists.
+ */
+async function resolveExistingConfigPath() {
+    const { localPath, userPath } = (0, config_1.getConfigPaths)();
+    try {
+        await fs_1.promises.access(localPath);
+        return localPath;
+    }
+    catch (_error) {
+        try {
+            await fs_1.promises.access(userPath);
+            return userPath;
+        }
+        catch (_innerError) {
+            return null;
+        }
+    }
+}
+/**
+ * Resolve the existing config file or write a sample one to the user
+ * config path. The `created` flag tells callers whether to print the
+ * new-file confirmation.
+ */
+async function ensureConfigFile() {
+    const { userPath } = (0, config_1.getConfigPaths)();
+    const existingPath = await resolveExistingConfigPath();
+    if (existingPath) {
+        return { path: existingPath, created: false };
+    }
+    const createdPath = await (0, config_1.createSampleConfig)(userPath);
+    return { path: createdPath, created: true };
+}

package/dist/src/commands/helpers/device-discovery.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverAndSelectDevice = discoverAndSelectDevice;
+const chalk_1 = __importDefault(require("chalk"));
+const ff1_discovery_1 = require("../../utilities/ff1-discovery");
+const device_lookup_1 = require("../../utilities/device-lookup");
+const device_normalize_1 = require("../../utilities/device-normalize");
+/**
+ * Run mDNS discovery and prompt the user to pick a device, fall back to
+ * manual entry, or skip when an existing device is already configured.
+ *
+ * Shared between `ff1 setup` and `ff1 device add` so both flows present
+ * the same selection UX and matching rules.
+ */
+async function discoverAndSelectDevice(ask, existingDevices, options) {
+    const allowSkip = options?.allowSkip && existingDevices.length > 0;
+    const discoveryResult = await (0, ff1_discovery_1.discoverFF1Devices)();
+    const discoveredDevices = discoveryResult.devices;
+    if (discoveryResult.error && discoveredDevices.length === 0) {
+        const errorMessage = discoveryResult.error.endsWith('.')
+            ? discoveryResult.error
+            : `${discoveryResult.error}.`;
+        console.log(chalk_1.default.dim(`mDNS discovery failed: ${errorMessage} Continuing with manual entry.`));
+    }
+    else if (discoveryResult.error) {
+        console.log(chalk_1.default.dim(`mDNS discovery warning: ${discoveryResult.error}`));
+    }
+    if (discoveredDevices.length > 0) {
+        console.log(chalk_1.default.green('\nFF1 devices on your network:'));
+        discoveredDevices.forEach((device, index) => {
+            const displayId = device.id || device.name || device.host;
+            const normalizedHost = (0, device_normalize_1.normalizeDeviceHost)(`${device.host}:${device.port}`);
+            const alreadyConfigured = !!(0, device_lookup_1.findExistingDeviceEntry)(existingDevices, normalizedHost, device.name || device.id || '', device.id, device.addresses);
+            const suffix = alreadyConfigured ? chalk_1.default.dim(' (already configured)') : '';
+            console.log(chalk_1.default.dim(`  ${index + 1}) ${displayId}${suffix}`));
+        });
+        const skipHint = allowSkip ? ', press Enter to skip' : '';
+        const prompt = `Select device [1-${discoveredDevices.length}], enter ID/host${skipHint}, or type m for manual entry: `;
+        while (true) {
+            const selectionAnswer = (await ask(prompt)).trim();
+            if (!selectionAnswer) {
+                if (allowSkip) {
+                    console.log(chalk_1.default.dim('Keeping existing devices.'));
+                    return { hostValue: '', discoveredName: '', skipped: true };
+                }
+                break;
+            }
+            const normalizedSelection = selectionAnswer.toLowerCase();
+            if (normalizedSelection === 'm') {
+                break;
+            }
+            const parsedIndex = Number.parseInt(selectionAnswer, 10);
+            if (!Number.isNaN(parsedIndex) &&
+                `${parsedIndex}` === selectionAnswer &&
+                parsedIndex >= 1 &&
+                parsedIndex <= discoveredDevices.length) {
+                const selected = discoveredDevices[parsedIndex - 1];
+                return {
+                    hostValue: (0, device_normalize_1.normalizeDeviceHost)(`${selected.host}:${selected.port}`),
+                    discoveredName: selected.name || selected.id || '',
+                    discoveredId: selected.id,
+                    discoveredAddresses: selected.addresses,
+                    skipped: false,
+                };
+            }
+            const normalizedWithPrefix = normalizedSelection.startsWith('ff1-')
+                ? normalizedSelection
+                : `ff1-${normalizedSelection}`;
+            // Also normalize the answer as a URL-form host so pasted URLs like
+            // "http://ff1-hh9jsnoc.local:1111" match the device's normalized host.
+            let normalizedSelectionAsHost = '';
+            try {
+                normalizedSelectionAsHost = (0, device_normalize_1.normalizeDeviceHost)(selectionAnswer).toLowerCase();
+            }
+            catch {
+                // not a valid URL — skip URL-form matching
+            }
+            const matched = discoveredDevices.find((device) => {
+                const deviceNormalizedHost = (0, device_normalize_1.normalizeDeviceHost)(`${device.host}:${device.port}`).toLowerCase();
+                const candidates = [device.id, device.name, device.host, `${device.host}:${device.port}`]
+                    .filter((value) => Boolean(value))
+                    .map((value) => value.toLowerCase());
+                return (candidates.includes(normalizedSelection) ||
+                    candidates.includes(normalizedWithPrefix) ||
+                    (normalizedSelectionAsHost !== '' && normalizedSelectionAsHost === deviceNormalizedHost));
+            });
+            if (matched) {
+                return {
+                    hostValue: (0, device_normalize_1.normalizeDeviceHost)(`${matched.host}:${matched.port}`),
+                    discoveredName: matched.name || matched.id || '',
+                    discoveredId: matched.id,
+                    discoveredAddresses: matched.addresses,
+                    skipped: false,
+                };
+            }
+            console.log(chalk_1.default.red('Invalid selection. Enter a number, m, or a discovered device ID/host.'));
+        }
+    }
+    else if (!discoveryResult.error) {
+        console.log(chalk_1.default.dim('No FF1 devices found via mDNS. Continuing with manual entry.'));
+    }
+    // Manual entry fallback
+    const idAnswer = await ask('Device ID or host (e.g. ff1-ABCD1234): ');
+    if (!idAnswer) {
+        return { hostValue: '', discoveredName: '', skipped: false };
+    }
+    return { hostValue: (0, device_normalize_1.normalizeDeviceIdToHost)(idAnswer), discoveredName: '', skipped: false };
+}

package/dist/src/commands/helpers/playlist-display.js

@@ -0,0 +1,161 @@
+"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.displayPlaylistSummary = displayPlaylistSummary;
+exports.printPlaylistSourceLoadFailure = printPlaylistSourceLoadFailure;
+exports.printPlaylistVerificationFailure = printPlaylistVerificationFailure;
+exports.validatePlaylistSource = validatePlaylistSource;
+exports.runValidateCommand = runValidateCommand;
+exports.runVerifyCommand = runVerifyCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const playlist_source_1 = require("../../utilities/playlist-source");
+/**
+ * Print the standard "playlist saved" footer with the next-step hint.
+ *
+ * Used by `chat` and `build` after they write a playlist to disk, so the
+ * surface message stays consistent across both commands.
+ */
+function displayPlaylistSummary(playlist, outputPath) {
+    console.log(chalk_1.default.green('\nPlaylist saved'));
+    console.log(chalk_1.default.dim(`  Output: ./${outputPath}`));
+    console.log(chalk_1.default.dim('  Next: play last | publish playlist'));
+    console.log();
+}
+/**
+ * Print a focused failure for playlist source loading problems with a
+ * URL-vs-file aware hint block.
+ */
+function printPlaylistSourceLoadFailure(source, error) {
+    const isUrl = (0, playlist_source_1.isPlaylistSourceUrl)(source);
+    if (isUrl) {
+        console.error(chalk_1.default.red('\nCould not load hosted playlist URL'));
+        console.error(chalk_1.default.red(`  Source: ${source}`));
+        console.error(chalk_1.default.red(`  Error: ${error.message}`));
+        console.log(chalk_1.default.yellow('\n  Hint:'));
+        console.log(chalk_1.default.yellow('    • Check the URL is reachable'));
+        console.log(chalk_1.default.yellow('    • Confirm the response is JSON'));
+        console.log(chalk_1.default.yellow('    • Use a local file path if network access is unavailable'));
+        return;
+    }
+    console.error(chalk_1.default.red(`\nCould not load playlist file`));
+    console.error(chalk_1.default.red(`  Source: ${source}`));
+    console.error(chalk_1.default.red(`  Error: ${error.message}`));
+}
+/**
+ * Print playlist validation failure details consistently for commands that
+ * validate structure before sending (for example `play`).
+ */
+function printPlaylistVerificationFailure(verifyResult, source) {
+    console.error(chalk_1.default.red(`\nPlaylist validation failed:${source ? ` (${source})` : ''}`), verifyResult.error);
+    if (verifyResult.details && verifyResult.details.length > 0) {
+        console.log(chalk_1.default.yellow('\n   Validation errors:'));
+        verifyResult.details.forEach((detail) => {
+            console.log(chalk_1.default.yellow(`     • ${detail.path}: ${detail.message}`));
+        });
+    }
+    console.log(chalk_1.default.yellow('\n   Use --skip-verify to play anyway (not recommended)\n'));
+}
+/**
+ * Load a playlist from a path or URL and run parse-only validation (`validatePlaylist`).
+ *
+ * The `validate` command uses this as the full check. The `verify` command uses it
+ * for the structure pass only, then runs `verifyPlaylist` for cryptographic checks.
+ */
+async function validatePlaylistSource(source) {
+    const loaded = await (0, playlist_source_1.loadPlaylistSource)(source);
+    const verifier = await Promise.resolve().then(() => __importStar(require('../../utilities/playlist-verifier')));
+    const { validatePlaylist } = verifier;
+    const verifyResult = await validatePlaylist(loaded.playlist);
+    return {
+        ...verifyResult,
+        playlist: verifyResult.valid ? loaded.playlist : undefined,
+    };
+}
+/**
+ * Run the `validate` command flow. It checks DP-1 structure only and does
+ * not require signatures or public keys.
+ */
+async function runValidateCommand(source) {
+    try {
+        console.log(chalk_1.default.blue('\nValidate playlist\n'));
+        const verifier = await Promise.resolve().then(() => __importStar(require('../../utilities/playlist-verifier')));
+        const { printVerificationResult } = verifier;
+        const result = await validatePlaylistSource(source);
+        printVerificationResult(result, source, { failureKind: 'structure' });
+        if (!result.valid) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        printPlaylistSourceLoadFailure(source, error);
+        process.exit(1);
+    }
+}
+/**
+ * Run the `verify` command flow: same DP-1 structure checks as `validate`, then
+ * cryptographic verification via dp1-js. Unsigned playlists fail at the crypto
+ * step. dp1-js `verifyPlaylist` uses the optional second argument **only** to
+ * verify legacy flat `signature` strings; `signatures[]` envelopes do not rely
+ * on it. When `--public-key` is omitted, the CLI may still pass a key derived
+ * from `playlist.privateKey` / `PLAYLIST_PRIVATE_KEY`; dp1-js ignores it unless
+ * the playlist is on the legacy signature path.
+ */
+async function runVerifyCommand(source, publicKey) {
+    try {
+        console.log(chalk_1.default.blue('\nVerify playlist\n'));
+        const verifier = await Promise.resolve().then(() => __importStar(require('../../utilities/playlist-verifier')));
+        const { printVerificationResult } = verifier;
+        const result = await validatePlaylistSource(source);
+        if (!result.valid) {
+            printVerificationResult(result, source, { failureKind: 'structure' });
+            process.exit(1);
+        }
+        const signedResult = await verifier.verifyPlaylist(result.playlist, publicKey);
+        const finalResult = signedResult.valid
+            ? { ...result, valid: true, error: undefined, details: undefined }
+            : { valid: false, error: signedResult.error, details: signedResult.details };
+        printVerificationResult(finalResult, source, { failureKind: 'signature' });
+        if (!signedResult.valid) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        printPlaylistSourceLoadFailure(source, error);
+        process.exit(1);
+    }
+}

package/dist/src/commands/helpers/prompt.js

@@ -0,0 +1,65 @@
+"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.createPrompt = createPrompt;
+exports.promptYesNo = promptYesNo;
+const readline = __importStar(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+function createPrompt() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ask = async (question) => new Promise((resolve) => {
+        rl.question(chalk_1.default.yellow(question), (answer) => {
+            resolve(answer.trim());
+        });
+    });
+    return {
+        ask,
+        close: () => rl.close(),
+    };
+}
+async function promptYesNo(ask, question, defaultYes = true) {
+    const suffix = defaultYes ? 'Y/n' : 'y/N';
+    const answer = (await ask(`${question} [${suffix}] `)).trim().toLowerCase();
+    if (!answer) {
+        return defaultYes;
+    }
+    return answer === 'y' || answer === 'yes';
+}