@feralfile/cli 1.1.4 → 1.3.0

package/dist/src/commands/find.js

@@ -0,0 +1,502 @@
+"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.findCommand = void 0;
+exports.parseLimitOption = parseLimitOption;
+exports.decideActions = decideActions;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const prompt_1 = require("./helpers/prompt");
+const marketplace_url_1 = require("../utilities/marketplace-url");
+const ff_marketplace_1 = require("../utilities/ff-marketplace");
+const objkt_marketplace_1 = require("../utilities/objkt-marketplace");
+const ab_marketplace_1 = require("../utilities/ab-marketplace");
+const fxhash_marketplace_1 = require("../utilities/fxhash-marketplace");
+const neort_marketplace_1 = require("../utilities/neort-marketplace");
+const raster_client_1 = require("../utilities/raster-client");
+const ff1_device_1 = require("../utilities/ff1-device");
+// nft-indexer + playlist-builder are still CommonJS; require keeps interop simple.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { getNFTTokenInfoBatch } = require('../utilities/nft-indexer');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { buildDP1Playlist, buildUrlItem } = require('../utilities/playlist-builder');
+/**
+ * Maximum item count for a single DP-1 playlist (v1.1 spec). Build paths
+ * that exceed this would silently produce a playlist that `validateDP1Playlist`
+ * rejects — so cap implicitly here and surface an actionable warning, and
+ * reject explicit `--limit > MAX` outright.
+ */
+const DP1_MAX_ITEMS = 1024;
+const RASTER_PAGE_SIZE = 100;
+exports.findCommand = new commander_1.Command('find')
+    .description('Find an artwork on the web and build a DP-1 playlist')
+    .argument('<input>', 'URL (Objkt / fxhash / Art Blocks / OpenSea / SuperRare / Feral File / Neort), `ethereum:{contract}:{tokenId}`, `tezos:{contract}:{tokenId}`, or a wallet address')
+    .option('-o, --output <path>', 'Save the playlist to this file (default: ./<slug>.json)')
+    .option('-l, --limit <n>', 'Max tokens to include from the series (default: all)')
+    .option('-p, --play', 'Play the playlist on an FF1 device after building')
+    .option('-d, --device <name>', 'Device to play on (used with --play; default: first configured)')
+    .option('--publish', 'Publish the playlist to a configured feed server')
+    .option('-s, --server <index>', 'Feed server index (used with --publish)')
+    .option('-y, --yes', 'Skip interactive prompts; defaults to Play unless --output or --publish is set')
+    .option('--skip-verify', 'Skip signature verification before --play (mirrors `ff-cli play --skip-verify`)')
+    .action(async (input, options) => {
+    try {
+        console.log(chalk_1.default.blue('\nFind on Feral File CLI\n'));
+        const parsed = (0, marketplace_url_1.parseFindInput)(input);
+        if (!parsed) {
+            console.error(chalk_1.default.red('Could not understand input.'));
+            console.error(chalk_1.default.dim('Supported URLs: Objkt, fxhash, Art Blocks, OpenSea, SuperRare, Feral File, Neort. ' +
+                'Or: `ethereum:{contract}:{tokenId}`, `tezos:{contract}:{tokenId}`, ' +
+                'or a wallet address (`0x...` / `tz1.../tz2.../tz3...`).'));
+            process.exit(1);
+        }
+        if (parsed.kind === 'unsupported') {
+            console.error(chalk_1.default.red(parsed.reason));
+            process.exit(1);
+        }
+        // Neort is off-chain; its items skip Raster + FF indexer entirely and
+        // build a DP-1 entry directly from Neort's API response.
+        if (parsed.kind === 'neort-art') {
+            await runNeortFind(parsed.id, options);
+            return;
+        }
+        const target = await resolveTarget(parsed, !!options.yes);
+        if (target.kind === 'series') {
+            console.log(chalk_1.default.cyan((0, raster_client_1.formatSummaryLine)(target.summary)));
+        }
+        else {
+            const { chain, contract, tokenId } = target.coords;
+            console.log(chalk_1.default.cyan(`Single token — ${chain} ${contract}:${tokenId}`));
+            console.log(chalk_1.default.dim("  (Raster doesn't index this series — building a one-item playlist.)"));
+        }
+        console.log();
+        const userLimit = parseLimitOption(options.limit);
+        const seriesTotal = target.kind === 'series' ? target.summary.tokenCount : 1;
+        // Implicit cap: no --limit + series > 1024 → cap to DP-1 max with a
+        // clear warning. Explicit `--limit > 1024` was already rejected by
+        // parseLimitOption, so reaching here means either capped-by-default or
+        // the user picked a value within spec.
+        const limit = Math.min(userLimit, DP1_MAX_ITEMS);
+        if (userLimit === Number.POSITIVE_INFINITY && seriesTotal > DP1_MAX_ITEMS) {
+            console.log(chalk_1.default.yellow(`Series has ${seriesTotal} tokens; DP-1 caps playlists at ${DP1_MAX_ITEMS}. ` +
+                `Building with the first ${DP1_MAX_ITEMS} — pass \`--limit N\` (≤ ${DP1_MAX_ITEMS}) for fewer.`));
+            console.log();
+        }
+        const willInclude = Math.min(seriesTotal, limit);
+        const shouldBuild = !!options.yes || !!options.output || (await confirmMakePlaylist(willInclude, seriesTotal));
+        if (!shouldBuild) {
+            console.log(chalk_1.default.dim('Cancelled.'));
+            return;
+        }
+        const tokens = target.kind === 'series' ? await fetchTokens(target.summary, limit) : [target.coords];
+        console.log(chalk_1.default.dim(`Indexing ${tokens.length} token${tokens.length === 1 ? '' : 's'} via FF indexer...`));
+        // Second positional arg on getNFTTokenInfoBatch is `duration` (DP-1 item
+        // display seconds), not concurrency — concurrency is hardcoded inside.
+        // Omit it so the default (10s) applies; no misleading constant on this side.
+        const items = await getNFTTokenInfoBatch(tokens.map((t) => ({
+            chain: t.chain,
+            contractAddress: t.contract,
+            tokenId: t.tokenId,
+        })));
+        if (!Array.isArray(items) || items.length === 0) {
+            console.error(chalk_1.default.red('No tokens could be indexed; cannot build playlist.'));
+            console.error(chalk_1.default.dim('  The FF indexer may be under load when warming a series of previously-unseen tokens.'));
+            console.error(chalk_1.default.dim('  Try `--limit 5` first to warm the cache, then re-run without --limit.'));
+            process.exit(1);
+        }
+        const title = playlistTitleFor(target, items);
+        const playlist = await buildDP1Playlist({ items, title });
+        const outputPath = options.output ?? `${playlist.slug || 'playlist'}.json`;
+        await fs_1.promises.writeFile(outputPath, JSON.stringify(playlist, null, 2));
+        console.log(chalk_1.default.green(`✓ Playlist saved to ${outputPath}`));
+        console.log(chalk_1.default.dim(`  ${items.length} item${items.length === 1 ? '' : 's'}`));
+        const dropped = tokens.length - items.length;
+        if (dropped > 0) {
+            console.log(chalk_1.default.dim(`  ${dropped} token${dropped === 1 ? '' : 's'} dropped during indexing`));
+        }
+        console.log();
+        const actions = await decideActions(options);
+        for (const action of actions) {
+            if (action === 'play') {
+                await doPlay(playlist, options.device, !!options.skipVerify);
+            }
+            else if (action === 'publish') {
+                await doPublish(outputPath, options.server, !!options.yes);
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError:'), error.message);
+        process.exit(1);
+    }
+});
+async function resolveTarget(parsed, skipPrompt) {
+    if (parsed.kind === 'token') {
+        return resolveCoords(parsed.coords);
+    }
+    if (parsed.kind === 'ff-url') {
+        const coords = await (0, ff_marketplace_1.resolveFeralFileToken)(parsed);
+        return resolveCoords(coords);
+    }
+    if (parsed.kind === 'objkt-alias') {
+        const contract = await (0, objkt_marketplace_1.resolveObjktAlias)(parsed.alias);
+        return resolveCoords({ chain: 'tezos', contract, tokenId: parsed.tokenId });
+    }
+    if (parsed.kind === 'ab-collection') {
+        const coords = await (0, ab_marketplace_1.resolveArtBlocksCollection)(parsed.slug);
+        return resolveCoords(coords);
+    }
+    if (parsed.kind === 'fxhash-iteration') {
+        const coords = await (0, fxhash_marketplace_1.resolveFxhashIteration)(parsed.slug);
+        return resolveCoords(coords);
+    }
+    if (parsed.kind === 'fxhash-project') {
+        const coords = await (0, fxhash_marketplace_1.resolveFxhashProject)(parsed.slug);
+        return resolveCoords(coords);
+    }
+    if (parsed.kind === 'address') {
+        const artistId = await (0, raster_client_1.resolveAddressToArtist)(parsed.address);
+        if (artistId === null) {
+            throw new Error(`No artist found on Raster for address ${parsed.address}. ` +
+                'Raster indexes artists by their on-chain addresses; this address may not yet be claimed.');
+        }
+        const catalog = await (0, raster_client_1.listArtistArtworks)(artistId);
+        if (catalog.length === 0) {
+            throw new Error('Artist has no artworks indexed on Raster.');
+        }
+        const picked = await pickFromCatalog(catalog, skipPrompt);
+        const summary = await (0, raster_client_1.getArtworkSummary)(picked.artworkId);
+        return { kind: 'series', summary };
+    }
+    // `unsupported` is handled upstream; this branch keeps the type narrowing honest.
+    throw new Error(`Unsupported parse result: ${parsed.kind}`);
+}
+/**
+ * Resolve on-chain coords to a target. If Raster doesn't index this token
+ * (404), fall back to single-token mode so we still build something playable.
+ */
+async function resolveCoords(coords) {
+    const lookup = await (0, raster_client_1.resolveTokenToArtwork)(coords.chain, coords.contract, coords.tokenId);
+    if (lookup === null) {
+        return { kind: 'single', coords };
+    }
+    const summary = await (0, raster_client_1.getArtworkSummary)(lookup.artworkId);
+    return { kind: 'series', summary };
+}
+/**
+ * Build the playlist title. For series, "Artist — Series Title". For a
+ * one-item fallback, use the indexer's token name (already in the item)
+ * with a fall-through to coords if name is missing.
+ */
+function playlistTitleFor(target, items) {
+    if (target.kind === 'series') {
+        const artistLabel = target.summary.artists.map((a) => a.name).join(', ') || 'Unknown artist';
+        return `${artistLabel} — ${target.summary.title}`;
+    }
+    return items[0]?.title ?? `Token ${target.coords.tokenId}`;
+}
+function parseLimitOption(limitStr) {
+    if (limitStr === undefined) {
+        return Number.POSITIVE_INFINITY;
+    }
+    // Strict integer parse: `Number('5abc')` is NaN, while `parseInt('5abc', 10)`
+    // returns 5 and silently truncates user input. Reject anything that isn't a
+    // clean positive integer.
+    const n = Number(limitStr);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
+        throw new Error(`Invalid --limit value: ${limitStr} (expected a positive integer)`);
+    }
+    if (n > DP1_MAX_ITEMS) {
+        throw new Error(`Invalid --limit value: ${n} exceeds DP-1 playlist max of ${DP1_MAX_ITEMS} items.`);
+    }
+    return n;
+}
+async function fetchTokens(summary, limit) {
+    const collected = [];
+    let cursor;
+    let skipped = 0;
+    while (collected.length < limit) {
+        const page = await (0, raster_client_1.listArtworkTokens)(summary.artworkId, {
+            cursor,
+            pageSize: RASTER_PAGE_SIZE,
+        });
+        skipped += page.skippedUnsupported;
+        for (const t of page.tokens) {
+            if (collected.length >= limit) {
+                break;
+            }
+            collected.push({
+                chain: t.chain,
+                contract: t.contractAddress,
+                tokenId: t.tokenId,
+            });
+        }
+        if (page.nextCursor === null) {
+            break;
+        }
+        cursor = page.nextCursor;
+    }
+    if (skipped > 0) {
+        console.log(chalk_1.default.yellow(`  Skipped ${skipped} token${skipped === 1 ? '' : 's'} on unsupported chains (FF indexer covers eth + tezos mainnet only).`));
+    }
+    return collected;
+}
+async function pickFromCatalog(catalog, skipPrompt) {
+    if (catalog.length === 1 || skipPrompt) {
+        return catalog[0];
+    }
+    console.log(chalk_1.default.cyan(`Found ${catalog.length} artworks for this artist:`));
+    catalog.forEach((row, i) => {
+        const count = `${row.tokenCount} token${row.tokenCount === 1 ? '' : 's'}`;
+        console.log(chalk_1.default.dim(`  ${i}: ${row.title} (${count})`));
+    });
+    console.log();
+    const prompt = (0, prompt_1.createPrompt)();
+    const answer = await prompt.ask(`Pick one (0-${catalog.length - 1}, default 0): `);
+    prompt.close();
+    console.log();
+    // Strict integer parse: Number.parseInt('5abc') silently returns 5; here we
+    // want '5abc' to be rejected outright. Same anti-pattern parseLimitOption fixes.
+    const index = answer ? Number(answer) : 0;
+    if (!Number.isInteger(index) || index < 0 || index >= catalog.length) {
+        throw new Error(`Invalid selection: "${answer}"`);
+    }
+    return catalog[index];
+}
+async function confirmMakePlaylist(count, total) {
+    const noun = total === 1 ? 'token' : 'tokens';
+    const label = count < total ? `${count} of ${total} ${noun}` : `${count} ${noun}`;
+    const prompt = (0, prompt_1.createPrompt)();
+    const yes = await (0, prompt_1.promptYesNo)(prompt.ask, `Build playlist with ${label}?`, true);
+    prompt.close();
+    console.log();
+    return yes;
+}
+/**
+ * Decide which post-build actions to run.
+ *
+ * Precedence: explicit flags (--play / --publish) win and may combine. If no
+ * flag is set, fall back to --yes default (Play) or an interactive 3-way
+ * prompt. Save is unconditional and already done before this is called.
+ */
+async function decideActions(options) {
+    const flagActions = [];
+    if (options.play) {
+        flagActions.push('play');
+    }
+    if (options.publish) {
+        flagActions.push('publish');
+    }
+    if (flagActions.length > 0) {
+        return flagActions;
+    }
+    // --output alone (with or without --yes) means "save mode" — the save was the action.
+    if (options.output) {
+        return [];
+    }
+    // --yes without --output defaults to Play (max-satisfaction default for scripted use).
+    if (options.yes) {
+        return ['play'];
+    }
+    return [await promptNextAction()];
+}
+async function promptNextAction() {
+    const prompt = (0, prompt_1.createPrompt)();
+    const answer = (await prompt.ask('Next? [P]lay on FF1 / just [S]ave / pub[L]ish to feed (default: Play): '))
+        .trim()
+        .toLowerCase();
+    prompt.close();
+    console.log();
+    if (!answer || answer === 'p' || answer === 'play' || answer === 'y' || answer === 'yes') {
+        return 'play';
+    }
+    if (answer === 's' || answer === 'save' || answer === 'n' || answer === 'no') {
+        return 'skip';
+    }
+    if (answer === 'l' || answer === 'pub' || answer === 'publish') {
+        return 'publish';
+    }
+    throw new Error(`Unrecognized choice: "${answer}". Use P, S, or L.`);
+}
+async function doPlay(playlist, deviceName, skipVerify) {
+    // Match `ff-cli play`'s verification gate: signed playlists are verified
+    // before device delivery; the same surface that play surfaces failures.
+    // `buildDP1Playlist` signs when a playlist private key is configured and
+    // silently continues unsigned otherwise — so when no key is set, the user
+    // sees an actionable error here instead of an unverifiable playlist on
+    // the wall.
+    if (!skipVerify) {
+        const { verifyPlaylist } = await Promise.resolve().then(() => __importStar(require('../utilities/playlist-verifier')));
+        console.log(chalk_1.default.cyan('Verify playlist'));
+        const verifyResult = await verifyPlaylist(playlist);
+        if (!verifyResult.valid) {
+            console.error(chalk_1.default.red('Playlist verification failed:'), verifyResult.error);
+            if (verifyResult.details && verifyResult.details.length > 0) {
+                for (const d of verifyResult.details) {
+                    console.error(chalk_1.default.dim(`  ${d.path}: ${d.message}`));
+                }
+            }
+            console.error(chalk_1.default.dim('  Tip: configure a playlist signing key (config or PLAYLIST_PRIVATE_KEY), ' +
+                'or pass --skip-verify to bypass.'));
+            process.exitCode = 1;
+            return;
+        }
+        console.log(chalk_1.default.green('✓ Verified\n'));
+    }
+    console.log(chalk_1.default.blue('Play on FF1'));
+    const result = await (0, ff1_device_1.sendPlaylistToDevice)({ playlist, deviceName });
+    if (result.success) {
+        console.log(chalk_1.default.green('✓ Playing'));
+        if (result.deviceName) {
+            console.log(chalk_1.default.dim(`  Device: ${result.deviceName}`));
+        }
+        if (result.device) {
+            console.log(chalk_1.default.dim(`  Host: ${result.device}`));
+        }
+        console.log();
+        return;
+    }
+    console.error(chalk_1.default.red('Play failed:'), result.error);
+    if (result.details) {
+        console.error(chalk_1.default.dim(`  Details: ${result.details}`));
+    }
+    process.exitCode = 1;
+}
+async function doPublish(savedPath, serverArg, nonInteractive) {
+    console.log(chalk_1.default.blue('Publish to feed'));
+    const { getFeedConfig } = await Promise.resolve().then(() => __importStar(require('../config')));
+    const { publishPlaylist } = await Promise.resolve().then(() => __importStar(require('../utilities/playlist-publisher')));
+    const feedConfig = getFeedConfig();
+    if (!feedConfig.baseURLs || feedConfig.baseURLs.length === 0) {
+        console.error(chalk_1.default.red('No feed servers configured.'));
+        console.error(chalk_1.default.yellow('  Add feed server URLs to config.json: feed.baseURLs'));
+        process.exitCode = 1;
+        return;
+    }
+    // Validate --server regardless of server count. parseInt('0abc') would
+    // silently truncate to 0 and route to a different server; with a single
+    // server configured the old code skipped --server validation entirely and
+    // accepted any garbage value while publishing to baseURLs[0].
+    let serverIndex = 0;
+    if (serverArg !== undefined) {
+        const n = Number(serverArg);
+        if (!Number.isInteger(n) || n < 0 || n >= feedConfig.baseURLs.length) {
+            console.error(chalk_1.default.red(`Invalid --server value: ${serverArg} (expected integer in 0..${feedConfig.baseURLs.length - 1})`));
+            process.exitCode = 1;
+            return;
+        }
+        serverIndex = n;
+    }
+    else if (feedConfig.baseURLs.length > 1) {
+        if (nonInteractive) {
+            console.error(chalk_1.default.red(`Multiple feed servers configured (${feedConfig.baseURLs.length}); pass --server <index> when running with --yes.`));
+            process.exitCode = 1;
+            return;
+        }
+        console.log(chalk_1.default.yellow(`Multiple feed servers configured:`));
+        feedConfig.baseURLs.forEach((url, i) => {
+            console.log(chalk_1.default.cyan(`  ${i}: ${url}`));
+        });
+        const prompt = (0, prompt_1.createPrompt)();
+        const answer = await prompt.ask('Select server (0-based index): ');
+        prompt.close();
+        console.log();
+        const n = Number(answer);
+        if (!Number.isInteger(n) || n < 0 || n >= feedConfig.baseURLs.length) {
+            console.error(chalk_1.default.red(`Invalid selection: ${answer} (expected integer in 0..${feedConfig.baseURLs.length - 1})`));
+            process.exitCode = 1;
+            return;
+        }
+        serverIndex = n;
+    }
+    const serverUrl = feedConfig.baseURLs[serverIndex];
+    const serverApiKey = feedConfig.servers?.[serverIndex]?.apiKey ?? feedConfig.apiKey;
+    const result = await publishPlaylist(savedPath, serverUrl, serverApiKey);
+    if (result.success) {
+        console.log(chalk_1.default.green('✓ Published'));
+        if (result.playlistId) {
+            console.log(chalk_1.default.dim(`  Playlist ID: ${result.playlistId}`));
+        }
+        if (result.feedServer) {
+            console.log(chalk_1.default.dim(`  Server: ${result.feedServer}`));
+        }
+        console.log();
+        return;
+    }
+    console.error(chalk_1.default.red('Publish failed:'), result.error);
+    if (result.message) {
+        console.error(chalk_1.default.dim(`  ${result.message}`));
+    }
+    process.exitCode = 1;
+}
+/**
+ * Neort flow. Off-chain platform with no on-chain coords, so we bypass
+ * Raster + FF indexer and construct a single-item DP-1 playlist directly
+ * from Neort's API response using the off-chain `provenance.offChainURI`
+ * shape produced by `buildUrlItem`.
+ */
+async function runNeortFind(id, options) {
+    const art = await (0, neort_marketplace_1.resolveNeortArt)(id);
+    const artistLabel = art.artistName || 'Unknown artist';
+    console.log(chalk_1.default.cyan(`Neort — ${artistLabel} — ${art.title}`));
+    console.log(chalk_1.default.dim('  (Off-chain platform; building a one-item playlist directly from Neort.)'));
+    console.log();
+    const shouldBuild = !!options.yes || !!options.output || (await confirmMakePlaylist(1, 1));
+    if (!shouldBuild) {
+        console.log(chalk_1.default.dim('Cancelled.'));
+        return;
+    }
+    const item = buildUrlItem(art.assetUrl, 10, { title: art.title });
+    const playlistTitle = `${artistLabel} — ${art.title}`;
+    const playlist = await buildDP1Playlist({ items: [item], title: playlistTitle });
+    const outputPath = options.output ?? `${playlist.slug || 'playlist'}.json`;
+    await fs_1.promises.writeFile(outputPath, JSON.stringify(playlist, null, 2));
+    console.log(chalk_1.default.green(`✓ Playlist saved to ${outputPath}`));
+    console.log(chalk_1.default.dim('  1 item'));
+    console.log();
+    const actions = await decideActions(options);
+    for (const action of actions) {
+        if (action === 'play') {
+            await doPlay(playlist, options.device, !!options.skipVerify);
+        }
+        else if (action === 'publish') {
+            await doPublish(outputPath, options.server, !!options.yes);
+        }
+    }
+}

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

@@ -12,7 +12,7 @@ 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
+ * Shared between `ff-cli setup` and `ff-cli device add` so both flows present
  * the same selection UX and matching rules.
  */
 async function discoverAndSelectDevice(ask, existingDevices, options) {

package/dist/src/commands/play.js

@@ -45,11 +45,13 @@ const playlist_display_1 = require("./helpers/playlist-display");
 // ff1-device is still CommonJS; require keeps the interop simple.
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const { sendPlaylistToDevice } = require('../utilities/ff1-device');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { signPlaylist } = require('../utilities/playlist-signer');
 exports.playCommand = new commander_1.Command('play')
     .description('Play a playlist or media URL on an FF1 device')
     .argument('<source>', 'Playlist file, playlist URL, or media URL')
     .option('-d, --device <name>', 'Device name (uses first device if not specified)')
-    .option('--skip-verify', 'Skip DP-1 structure validation (parse/schema) before playing; use only when you accept malformed envelopes')
+    .option('--skip-verify', 'Skip signature verification and auto-sign gating before playing; use only when you accept malformed envelopes')
     .action(async (source, options) => {
     try {
         const config = (0, config_1.getConfig)();
@@ -60,20 +62,59 @@ exports.playCommand = new commander_1.Command('play')
             : resolved.source;
         console.log(chalk_1.default.blue('\nPlay on FF1\n'));
         if (!options.skipVerify) {
-            // Structure-only validation (same as `validate`, `verify`, send, and publish).
-            // Synthesized media-URL playlists are unsigned but parse as valid DP-1.
+            const playlistConfig = config.playlist;
+            const privateKey = playlistConfig?.privateKey || process.env.PLAYLIST_PRIVATE_KEY;
+            const { verifyPlaylist } = await Promise.resolve().then(() => __importStar(require('../utilities/playlist-verifier')));
             if (isPlaylistSource) {
-                console.log(chalk_1.default.cyan(`Validate playlist (${sourceLabel})`));
+                console.log(chalk_1.default.cyan(`Verify playlist (${sourceLabel})`));
             }
-            const verifier = await Promise.resolve().then(() => __importStar(require('../utilities/playlist-verifier')));
-            const { validatePlaylist } = verifier;
-            const validateResult = await validatePlaylist(resolved.playlist);
-            if (!validateResult.valid) {
-                (0, playlist_display_1.printPlaylistVerificationFailure)(validateResult, isPlaylistSource ? `source: ${sourceLabel}` : undefined);
+            const verifyResult = resolved.kind === 'media'
+                ? await (async () => {
+                    try {
+                        if (!privateKey) {
+                            return {
+                                valid: false,
+                                error: 'Cannot sign playlist for playback: no playlist signing key is configured',
+                            };
+                        }
+                        const signature = await signPlaylist(resolved.playlist, privateKey);
+                        const signedPlaylist = {
+                            ...resolved.playlist,
+                            signature: undefined,
+                            signatures: [signature],
+                        };
+                        const signedVerification = await verifyPlaylist(signedPlaylist);
+                        if (signedVerification.valid) {
+                            resolved.playlist = signedPlaylist;
+                            return { valid: true, playlist: signedPlaylist };
+                        }
+                        return {
+                            valid: false,
+                            error: signedVerification.error,
+                            details: signedVerification.details,
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            valid: false,
+                            error: `Failed to sign playlist for playback: ${error.message}`,
+                        };
+                    }
+                })()
+                : await verifyPlaylist(resolved.playlist);
+            if (!verifyResult.valid) {
+                (0, playlist_display_1.printPlaylistVerificationFailure)({
+                    valid: false,
+                    error: verifyResult.error,
+                    details: verifyResult.details,
+                }, isPlaylistSource ? `source: ${sourceLabel}` : undefined);
                 process.exit(1);
             }
-            if (isPlaylistSource) {
-                console.log(chalk_1.default.green('✓ Validated\n'));
+            if (resolved.kind === 'media') {
+                console.log(chalk_1.default.green('✓ Signed and verified\n'));
+            }
+            else if (isPlaylistSource) {
+                console.log(chalk_1.default.green('✓ Verified\n'));
             }
         }
         const result = await sendPlaylistToDevice({

package/dist/src/commands/setup.js

@@ -34,7 +34,7 @@ exports.setupCommand = new commander_1.Command('setup')
             console.error(chalk_1.default.red('No models found in config.json'));
             process.exit(1);
         }
-        console.log(chalk_1.default.blue('\nFF1 Setup\n'));
+        console.log(chalk_1.default.blue('\nff-cli setup\n'));
         prompt = (0, prompt_1.createPrompt)();
         const ask = prompt.ask;
         const currentModel = config.defaultModel && modelNames.includes(config.defaultModel)

package/dist/src/commands/status.js

@@ -17,7 +17,7 @@ exports.statusCommand = new commander_1.Command('status')
         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'));
+            console.log(chalk_1.default.dim('Run: ff-cli setup'));
             process.exit(1);
         }
         const config = await (0, config_files_1.readConfigFile)(configPath);
@@ -106,7 +106,7 @@ exports.statusCommand = new commander_1.Command('status')
         });
         const hasRequired = statuses.some((status) => !status.ok && (!status.optional || Boolean(status.invalid)));
         if (hasRequired) {
-            console.log(chalk_1.default.dim('\nRun: ff1 setup'));
+            console.log(chalk_1.default.dim('\nRun: ff-cli setup'));
             process.exit(1);
         }
     }