@feralfile/cli 3.0.0 → 4.0.0

package/dist/src/commands/helpers/hidden-alias-help.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hiddenAliasHelp = void 0;
+const commander_1 = require("commander");
+/**
+ * dropAlias removes `cmd`'s first alias from a help term commander built, turning `display|play` back
+ * into `display`.
+ *
+ * Commander adds the alias as `name|alias` in exactly these two terms and nowhere else, so replacing
+ * that one token is enough; rebuilding the terms from scratch would copy commander internals that
+ * are not exported (humanReadableArgName).
+ *
+ * @param {string} term - The term commander built
+ * @param {Command} cmd - The command it describes
+ * @returns {string} The term without the alias
+ */
+function dropAlias(term, cmd) {
+    const alias = cmd.alias();
+    return alias ? term.replace(`${cmd.name()}|${alias}`, cmd.name()) : term;
+}
+/**
+ * hiddenAliasHelp is a commander help configuration that names a command by its name only, never
+ * by its alias.
+ *
+ * An alias in ff-cli is a retired command name kept so existing scripts and agents keep working:
+ * `play` became `display` (B&F weekly 2026-11-03; Canon reference/naming-brand.md §3.4). Commander
+ * would print it in the command list and the usage line (`display|play`), and help is where people
+ * and agents learn the CLI's words, so printing it would teach the retired verb again. The alias
+ * still parses and `ff-cli help play` still works; only the printed help drops it.
+ *
+ * Apply it to the program (the command list uses subcommandTerm) and to every aliased command (its
+ * own usage line uses commandUsage): `addCommand` does not copy help configuration to subcommands.
+ */
+exports.hiddenAliasHelp = {
+    subcommandTerm: (cmd) => dropAlias(new commander_1.Help().subcommandTerm(cmd), cmd),
+    commandUsage: (cmd) => dropAlias(new commander_1.Help().commandUsage(cmd), cmd),
+};

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

@@ -3,7 +3,6 @@ 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;
@@ -11,18 +10,6 @@ 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.
@@ -45,7 +32,7 @@ function printPlaylistSourceLoadFailure(source, error) {
 }
 /**
  * Print playlist validation failure details consistently for commands that
- * validate structure before sending (for example `play`).
+ * validate structure before sending (for example `display`).
  */
 function printPlaylistVerificationFailure(verifyResult, source) {
     console.error(chalk_1.default.red(`\nPlaylist validation failed:${source ? ` (${source})` : ''}`), verifyResult.error);
@@ -55,7 +42,7 @@ function printPlaylistVerificationFailure(verifyResult, source) {
             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'));
+    console.log(chalk_1.default.yellow('\n   Use --skip-verify to display anyway (not recommended)\n'));
 }
 /**
  * Load a playlist from a path or URL and run parse-only validation (`validatePlaylist`).

package/dist/src/commands/play.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.playCommand = void 0;
+exports.displayCommand = void 0;
 exports.describeDiscoveryInput = describeDiscoveryInput;
 exports.probeDiscoveryUrlAsPlaylist = probeDiscoveryUrlAsPlaylist;
 const commander_1 = require("commander");
@@ -13,20 +13,21 @@ const config_1 = require("../config");
 const playlist_source_1 = require("../utilities/playlist-source");
 const playlist_cast_1 = require("../utilities/playlist-cast");
 const playlist_display_1 = require("./helpers/playlist-display");
+const hidden_alias_help_1 = require("./helpers/hidden-alias-help");
 /**
- * Human label for a discovery input that `play` cannot cast directly.
+ * Human label for a discovery input that `display` cannot cast directly.
  *
- * `play` casts an exact, already-playable source (a playlist file, a hosted
- * playlist URL, or a direct media/web URL). A marketplace URL, on-chain
+ * `display` casts an exact source it can send as it is (a playlist file, a
+ * hosted playlist URL, or a direct media/web URL). A marketplace URL, on-chain
  * coordinates, or a wallet address must be *resolved* through the indexer
- * first — that is `find`'s job. Returns a label for those inputs so `play`
+ * first — that is `find`'s job. Returns a label for those inputs so `display`
  * can redirect the user instead of silently wrapping, say, an Art Blocks
- * collection *page* as a web item. Returns null for anything `play` should
+ * collection *page* as a web item. Returns null for anything `display` should
  * handle itself (plain URLs and file paths parse to null here).
  *
  * A recognized-but-`unsupported` result (e.g. a legacy Art Blocks
  * `/projects/{id}` URL, or an unsupported-chain OpenSea link) is also a
- * discovery input — it's a marketplace URL, not a playable file — so it is
+ * discovery input — it's a marketplace URL, not a file it can send — so it is
  * redirected to `find` too, which surfaces the specific reason.
  */
 function describeDiscoveryInput(source) {
@@ -72,11 +73,11 @@ function describeDiscoveryInput(source) {
  * which wrongly redirected DP-1 feed playlist URLs
  * (https://feed.feralfile.com/api/v1/playlists/{slug}, exactly the URLs the
  * feed hands out) to `find`, which has no feed route either; the documented
- * "hosted playlist URL plays directly" contract was unreachable for them
+ * "hosted playlist URL displays directly" contract was unreachable for them
  * (found 2026-08-02 casting a published playlist to an FF1).
  *
  * Probing the document keeps both behaviors without a host allowlist: a URL
- * that serves DP-1 JSON (`dpVersion` marker) plays directly; a marketplace
+ * that serves DP-1 JSON (`dpVersion` marker) displays directly; a marketplace
  * *page* fails the probe (non-JSON, or JSON with no marker) and still
  * redirects to `find` instead of being wrapped as a web item. The probe
  * costs one fetch before a redirect, only for discovery inputs that are
@@ -84,7 +85,7 @@ function describeDiscoveryInput(source) {
  *
  * A URL that does not exist (404/410, no such host, a broken `.json` link)
  * is refused here rather than redirected: the redirect also suggests
- * `play --web`, which would cast the error page.
+ * `display --web`, which would cast the error page.
  *
  * @throws {Error} When the URL does not exist (refusalForLoadFailure)
  */
@@ -114,14 +115,14 @@ async function probeDiscoveryUrlAsPlaylist(source) {
     }
 }
 /**
- * resolveWebPageSource wraps `source` as a web page for `play --web`, without
+ * resolveWebPageSource wraps `source` as a web page for `display --web`, without
  * the discovery redirect or the playlist probe.
  *
  * `--web` exists because the discovery parser claims whole hosts: any page on
  * feralfile.com, opensea.io, objkt.com and the like is redirected to `find`,
  * and `find` rejects every page that is not an artwork it can resolve (a
  * homepage, an exhibition overview, a profile). Before `--web` there was no
- * way to put such a page on a wall; the two commands pointed at each other.
+ * way to put such a page on display; the two commands pointed at each other.
  *
  * @param {string} source - The URL the caller passed
  * @returns {Promise<PlaySource>} A `media` source with a `text/html` item
@@ -135,12 +136,24 @@ async function resolveWebPageSource(source) {
     const note = await (0, playlist_source_1.checkWebPageUrl)(url);
     return (0, playlist_source_1.buildMediaPlaySource)(url, { asWebPage: true, note });
 }
-exports.playCommand = new commander_1.Command('play')
-    .description('Play a playlist file, playlist URL, media URL, or web page on an FF1 device')
+/**
+ * displayCommand puts a playlist, media URL, or web page on an FF1.
+ *
+ * The verb for art is display, not play (B&F weekly 2026-11-03; Canon
+ * reference/naming-brand.md §3.4): people play games and video, they display
+ * art. `play` was this command's name, so it stays as an alias that existing
+ * scripts and agents keep calling; hiddenAliasHelp keeps it out of every help
+ * screen so help teaches only `display`. Do not drop the alias without a
+ * decision to break those callers.
+ */
+exports.displayCommand = new commander_1.Command('display')
+    .alias('play')
+    .configureHelp(hidden_alias_help_1.hiddenAliasHelp)
+    .description('Display a playlist file, playlist URL, media URL, or web page on an FF1 device')
     .argument('<source>', 'Playlist file, playlist URL, or any media or web page URL')
     .option('-d, --device <name>', 'Device name (uses first device if not specified)')
-    .option('--web', 'Play the URL as a web page, even on a marketplace site where play would otherwise send you to find')
-    .option('--skip-verify', 'Skip signature verification and auto-sign gating before playing; use only when you accept malformed envelopes')
+    .option('--web', 'Display the URL as a web page, even on a marketplace site where display would otherwise send you to find')
+    .option('--skip-verify', 'Skip signature verification and auto-sign gating before displaying; use only when you accept malformed envelopes')
     .action(async (source, options) => {
     try {
         const resolved = options.web
@@ -159,14 +172,14 @@ exports.playCommand = new commander_1.Command('play')
     }
 });
 /**
- * resolveDefaultSource resolves a `play` argument without `--web`: discovery
+ * resolveDefaultSource resolves a `display` argument without `--web`: discovery
  * inputs go to `find`, everything else loads as a playlist or wraps as media.
  *
- * `play` casts an exact playable source. A marketplace URL / on-chain coords /
+ * `display` casts an exact source as it is. A marketplace URL / on-chain coords /
  * wallet must be resolved through the indexer first, so it redirects to `find`
  * rather than silently wrapping the *page* as a web item. Exception: a
  * discovery-classified URL that actually serves a DP-1 playlist document (the
- * discovery parser claims whole hosts, catching feed playlist URLs) plays
+ * discovery parser claims whole hosts, catching feed playlist URLs) displays
  * directly; see probeDiscoveryUrlAsPlaylist. The redirect names `--web` too,
  * for the caller who did mean the page.
  *
@@ -181,12 +194,12 @@ async function resolveDefaultSource(source, device) {
         probed = await probeDiscoveryUrlAsPlaylist(source);
     }
     if (discovery && !probed) {
-        console.error(chalk_1.default.red('\n`play` casts an exact playlist or media URL — it does not search marketplaces.'));
+        console.error(chalk_1.default.red('\n`display` casts an exact playlist or media URL — it does not search marketplaces.'));
         console.error(chalk_1.default.dim(`  "${source}" looks like ${discovery}, which needs to be resolved first.`));
         const deviceFlag = device ? ` -d "${device}"` : '';
-        console.log(chalk_1.default.yellow(`\nTry:  ff-cli find "${source}" --play -y${deviceFlag}`));
+        console.log(chalk_1.default.yellow(`\nTry:  ff-cli find "${source}" --display -y${deviceFlag}`));
         if ((0, playlist_source_1.isPlaylistSourceUrl)(source)) {
-            console.log(chalk_1.default.dim(`To show the page itself:  ff-cli play --web "${source}"${deviceFlag}`));
+            console.log(chalk_1.default.dim(`To show the page itself:  ff-cli display --web "${source}"${deviceFlag}`));
         }
         process.exit(1);
     }
@@ -199,7 +212,7 @@ async function resolveDefaultSource(source, device) {
  * a resolved source, then reports the outcome. Exits 1 on any failure.
  *
  * @param {PlaySource} resolved - What to cast
- * @param {Object} options - The `play` options
+ * @param {Object} options - The `display` options
  * @returns {Promise<void>}
  */
 async function castResolved(resolved, options) {
@@ -207,7 +220,7 @@ async function castResolved(resolved, options) {
     const sourceLabel = isPlaylistSource
         ? `${resolved.sourceType}: ${resolved.source}`
         : resolved.source;
-    console.log(chalk_1.default.blue('\nPlay on FF1\n'));
+    console.log(chalk_1.default.blue('\nDisplay on FF1\n'));
     if (resolved.kind === 'media' && resolved.note) {
         console.log(chalk_1.default.yellow(resolved.note));
     }
@@ -236,7 +249,7 @@ async function castResolved(resolved, options) {
             console.error(chalk_1.default.red(`\n${result.error}`));
         }
         else {
-            console.error(chalk_1.default.red('\nPlay failed:'), result.error);
+            console.error(chalk_1.default.red('\nDisplay failed:'), result.error);
             if (result.deviceDetails) {
                 console.error(chalk_1.default.dim(`  Details: ${result.deviceDetails}`));
             }
@@ -246,7 +259,7 @@ async function castResolved(resolved, options) {
     if (result.verified) {
         console.log(chalk_1.default.green(result.signed ? '✓ Signed and verified\n' : '✓ Verified\n'));
     }
-    console.log(chalk_1.default.green('✓ Playing'));
+    console.log(chalk_1.default.green('✓ Displaying'));
     if (result.deviceName) {
         console.log(chalk_1.default.dim(`  Device: ${result.deviceName}`));
     }

package/dist/src/commands/report.js

@@ -0,0 +1,251 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const config_1 = require("../config");
+const ff1_compatibility_1 = require("../utilities/ff1-compatibility");
+const support_report_1 = require("../utilities/support-report");
+/** REPORT_HELP says what a report carries, so a caller knows what leaves the machine before sending. */
+const REPORT_HELP = `
+The report text comes from --message or --file (not both), or from stdin when
+neither is given and stdin is not a terminal. It goes privately to Feral File
+support with this ff-cli version, the OS, and the Node version, and with
+--email when given. Nothing else leaves this computer: no config, keys, or
+playlists.
+
+With -d, the report also carries the Art Computer's device ID, FF OS version and
+branch, and once it is in, the Art Computer is asked to upload its logs under
+the same reference. It uploads in the background and needs internet. On FF OS
+with secure control, that request needs ff-cli paired with the owner role.
+
+Exit status: 0 when the report reached Feral File support, even if the Art
+Computer did not take the log request; 1 when it did not.
+
+Examples:
+  ff-cli report --message "The work displays black on the Art Computer; in a desktop browser it renders." -d Office
+  ff-cli report --file report.txt --email you@example.com
+  printf '%s\\n' "$REPORT" | ff-cli report -d Office --dry-run
+`;
+/**
+ * `ff-cli report` sends a problem report to Feral File support, the same
+ * pipeline the app's Support & Feedback feeds, so an agent driving ff-cli can
+ * report what went wrong without a person pressing send. The wire contract and
+ * what may be sent live in utilities/support-report.ts.
+ */
+exports.reportCommand = new commander_1.Command('report')
+    .description("Send a problem report to Feral File support, with an Art Computer's logs when one is involved")
+    .option('--message <text>', 'The report text')
+    .option('--file <path>', 'Read the report text from this file')
+    .option('--email <address>', 'Where Feral File support may reply: a bare address, name@example.com')
+    .option('-d, --device <name>', 'The Art Computer involved: adds its device ID, version and branch, and asks it to upload its logs')
+    .option('--dry-run', 'Print the JSON that would be sent, and send nothing')
+    .addHelpText('after', REPORT_HELP)
+    .action(async (options, command) => {
+    try {
+        // The program's own version, so the report carries exactly what
+        // `ff-cli --version` prints (index.ts reads the root package.json).
+        await runReport(options, command.parent?.version() || 'unknown');
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError:'), error.message);
+        process.exit(1);
+    }
+});
+/**
+ * runReport checks the report, reads the Art Computer's status, posts the
+ * report, then asks the Art Computer for its logs. Every refusal before the
+ * post exits 1 with nothing sent; after the post the exit status is 0.
+ *
+ * @param options - Command options
+ * @param ffCliVersion - The version `ff-cli --version` prints
+ * @returns Promise that resolves when the report is done
+ */
+async function runReport(options, ffCliVersion) {
+    const report = await readReport(options);
+    const email = options.email?.trim();
+    checkReport(report, email);
+    const { baseUrl } = (0, config_1.getSupportLogsConfig)();
+    const device = options.device !== undefined ? selectDevice(options.device) : undefined;
+    const deviceBlock = device ? await describeDevice(device) : undefined;
+    // One serialization, so --dry-run prints the very bytes a real run posts.
+    const payload = (0, support_report_1.buildReportPayload)({ report, ffCliVersion, email, device: deviceBlock });
+    const body = JSON.stringify(payload, null, 2);
+    if (options.dryRun) {
+        printDryRun(body, baseUrl, device);
+        return;
+    }
+    const posted = await (0, support_report_1.postReport)(baseUrl, body);
+    if (posted.ok === false) {
+        exitWith(posted);
+    }
+    printReceipt(posted.receipt, email);
+    await askForLogs(device, posted.receipt);
+}
+/**
+ * readReport returns the trimmed report text from exactly one source. Flags
+ * win and stdin is read only when neither is given: an agent's stdin is often
+ * a pipe that carries nothing, and reading it beside a flag would wait on it.
+ *
+ * @param options - Command options
+ * @returns The report text, possibly empty
+ */
+async function readReport(options) {
+    if (options.message !== undefined && options.file !== undefined) {
+        exitWith({ error: 'Give the report once: --message or --file, not both.' });
+    }
+    if (options.message !== undefined) {
+        return options.message.trim();
+    }
+    if (options.file !== undefined) {
+        try {
+            return (await fs_1.promises.readFile(options.file, 'utf-8')).trim();
+        }
+        catch (error) {
+            exitWith({ error: `Could not read --file ${options.file}: ${error.message}` });
+        }
+    }
+    if (process.stdin.isTTY) {
+        exitWith({
+            error: 'No report given.',
+            details: 'Pass --message "<text>" or --file <path>, or pipe the text on stdin.',
+        });
+    }
+    return (await readStdin()).trim();
+}
+/** readStdin reads all of stdin as UTF-8. */
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', reject);
+    });
+}
+/**
+ * checkReport refuses a report support-logs would refuse, a reply address
+ * that is not one, and a report carrying this computer's signing key.
+ *
+ * @param report - Trimmed report text
+ * @param email - Trimmed --email value; an empty one is refused, not dropped
+ */
+function checkReport(report, email) {
+    if (!report) {
+        exitWith({
+            error: 'The report is empty.',
+            details: 'If the text came from a shell variable, check that it is set.',
+        });
+    }
+    const bytes = Buffer.byteLength(report, 'utf8');
+    if (bytes > support_report_1.MAX_REPORT_BYTES) {
+        exitWith({
+            error: `The report is ${bytes} bytes; Feral File support takes at most ${support_report_1.MAX_REPORT_BYTES}.`,
+            details: "Shorten it. With -d the Art Computer's logs travel separately, so leave log excerpts out.",
+        });
+    }
+    if (email !== undefined && !(0, support_report_1.isBareAddress)(email)) {
+        exitWith({
+            error: `--email "${email}" is not an address Feral File support can reply to.`,
+            details: 'Give a bare ASCII address such as name@example.com, at most 254 characters. ' +
+                "Before the @: 1-64 characters of letters, digits and ! # $ % & ' * + / = ? ^ _ ` { | } ~ -, with single dots only between them. " +
+                'After it: two or more dot-separated labels of letters, digits and hyphens, no label starting or ending with a hyphen. ' +
+                'No display name, angle brackets, quotes, spaces, IP address, underscore in the domain, or non-ASCII characters.',
+        });
+    }
+    if (email !== undefined && (0, support_report_1.isReservedAddress)(email)) {
+        exitWith({
+            error: `--email "${email}" is an address Feral File support does not reply to.`,
+            details: "Support's own address and postmaster or mailer-daemon mailboxes are refused. Give the address where you want the reply, or leave --email out.",
+        });
+    }
+    if ((0, support_report_1.containsSigningKey)(report, (0, config_1.getPlaylistConfig)().privateKey)) {
+        exitWith({
+            error: "The report contains this computer's playlist signing key.",
+            details: 'Remove the key and run the command again. Nothing was sent.',
+        });
+    }
+}
+/** selectDevice resolves -d the way `display -d` does, or exits 1 naming the configured devices. */
+function selectDevice(name) {
+    const selected = (0, ff1_compatibility_1.resolveConfiguredDevice)(name);
+    if (!selected.success || !selected.device) {
+        exitWith({ error: selected.error || 'The Art Computer is not configured correctly.' });
+    }
+    return selected.device;
+}
+/** describeDevice reads the Art Computer block, noting a failed status read without stopping. */
+async function describeDevice(device) {
+    const status = await (0, support_report_1.readDeviceStatus)(device);
+    if (status.error) {
+        console.error(chalk_1.default.yellow(`Could not read the status of ${deviceLabel(device)} (${status.error}); the report goes without its version and branch.`));
+    }
+    return status.device;
+}
+/** printDryRun prints the body on stdout and what a real run would do on stderr. */
+function printDryRun(body, baseUrl, device) {
+    process.stdout.write(`${body}\n`);
+    console.error(chalk_1.default.dim(`Dry run: nothing was sent. A real run posts this to ${baseUrl}/v2/cli/reports`));
+    if (device) {
+        console.error(chalk_1.default.dim(`Then it asks ${deviceLabel(device)} to upload its logs under the reference that comes back.`));
+    }
+}
+/** printReceipt reports the reference in the app's `Support [<id>]` form and who support can reply to. */
+function printReceipt(receipt, email) {
+    console.log(chalk_1.default.green('✓ Report sent to Feral File support'));
+    console.log(`  Reference: Support [${receipt.supportBundleId}]`);
+    console.log(chalk_1.default.dim(email
+        ? `  Support may reply to ${email}`
+        : '  No --email given, so support has no address to reply to'));
+}
+/**
+ * askForLogs asks the Art Computer to upload its logs under the report's
+ * reference and prints the outcome. Best effort: a failure prints a line and
+ * leaves the exit status at 0, since the report already reached support.
+ *
+ * @param device - Art Computer named with -d, if any
+ * @param receipt - The posted report's receipt
+ */
+async function askForLogs(device, receipt) {
+    if (!device) {
+        console.log(chalk_1.default.dim('  No Art Computer named (-d), so no device logs were requested'));
+        return;
+    }
+    const label = deviceLabel(device);
+    if (!receipt.uploadToken) {
+        console.log(chalk_1.default.yellow(`${label} was not asked to upload its logs: support returned no upload token.`));
+        return;
+    }
+    const result = await (0, support_report_1.requestLogUpload)(device, {
+        supportBundleId: receipt.supportBundleId,
+        uploadToken: receipt.uploadToken,
+    });
+    if (result.success) {
+        console.log(chalk_1.default.green(`✓ Asked ${label} to upload its logs under the same reference`));
+        console.log(chalk_1.default.dim('  It uploads in the background and needs internet to do it'));
+        return;
+    }
+    console.log(chalk_1.default.yellow(`${label} did not take the request to upload its logs: ${result.error}`));
+    if (result.details) {
+        console.log(chalk_1.default.dim(`  ${result.details}`));
+    }
+    console.log(chalk_1.default.dim('  The report itself reached support.'));
+}
+/** deviceLabel names a device in output. */
+function deviceLabel(device) {
+    return device.name || device.host;
+}
+/** exitWith prints a failure and exits 1. */
+function exitWith(failure) {
+    console.error(chalk_1.default.red(`\n${failure.error}`));
+    if (failure.details) {
+        console.error(chalk_1.default.dim(`  ${failure.details}`));
+    }
+    process.exit(1);
+}

package/dist/src/commands/setup.js

@@ -318,7 +318,7 @@ exports.setupCommand = new commander_1.Command('setup')
                 console.log(chalk_1.default.yellow('  • Add an FF1 device host'));
             }
         }
-        console.log(chalk_1.default.dim('\nRun: ff-cli play <url-or-playlist>'));
+        console.log(chalk_1.default.dim('\nRun: ff-cli display <url-or-playlist>'));
     }
     catch (error) {
         console.error(chalk_1.default.red('\nSetup failed:'), error.message);