ff1-cli 1.0.1 → 1.0.3

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

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverFF1Devices = discoverFF1Devices;
+const bonjour_service_1 = require("bonjour-service");
+const DEFAULT_TIMEOUT_MS = 2000;
+/**
+ * Normalize mDNS TXT records to string values.
+ *
+ * @param {Record<string, unknown> | undefined} record - Raw TXT record object from mDNS
+ * @returns {Record<string, string>} Normalized TXT records
+ * @example
+ * normalizeTxtRecords({ id: 'ff1-1234', name: 'Studio FF1' });
+ */
+function normalizeTxtRecords(record) {
+    if (!record) {
+        return {};
+    }
+    return Object.entries(record).reduce((accumulator, [key, value]) => {
+        if (typeof value === 'string') {
+            accumulator[key] = value;
+            return accumulator;
+        }
+        if (Buffer.isBuffer(value)) {
+            accumulator[key] = value.toString('utf8');
+            return accumulator;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            accumulator[key] = String(value);
+        }
+        return accumulator;
+    }, {});
+}
+/**
+ * Normalize mDNS hostnames by trimming a trailing dot.
+ *
+ * @param {string} host - Raw host from mDNS results
+ * @returns {string} Normalized host
+ * @example
+ * normalizeMdnsHost('ff1-1234.local.');
+ */
+function normalizeMdnsHost(host) {
+    return host.endsWith('.') ? host.slice(0, -1) : host;
+}
+/**
+ * Extract a hostname-based ID from an mDNS host when possible.
+ *
+ * @param {string} host - Normalized mDNS host
+ * @returns {string} Hostname-based ID when available
+ * @example
+ * getHostnameId('ff1-03vdu3x1.local');
+ */
+function getHostnameId(host) {
+    if (!host) {
+        return '';
+    }
+    if (host.includes(':')) {
+        return '';
+    }
+    if (/^[0-9.]+$/.test(host)) {
+        return '';
+    }
+    if (host.endsWith('.local')) {
+        return host.split('.')[0] || '';
+    }
+    if (!host.includes('.')) {
+        return host;
+    }
+    return '';
+}
+/**
+ * Discover FF1 devices via mDNS using the `_ff1._tcp` service.
+ *
+ * @param {Object} [options] - Discovery options
+ * @param {number} [options.timeoutMs] - How long to browse before returning results
+ * @returns {Promise<FF1DiscoveryResult>} Discovered FF1 devices and optional error
+ * @throws {Error} Never throws; returns empty list on errors
+ * @example
+ * const result = await discoverFF1Devices({ timeoutMs: 2000 });
+ */
+async function discoverFF1Devices(options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return new Promise((resolve) => {
+        let resolved = false;
+        const finish = (result, error) => {
+            if (resolved) {
+                return;
+            }
+            resolved = true;
+            resolve({ devices: result, error });
+        };
+        try {
+            const bonjour = new bonjour_service_1.Bonjour();
+            const devices = new Map();
+            const browser = bonjour.find({ type: 'ff1', protocol: 'tcp' });
+            const finalize = (error) => {
+                try {
+                    browser.stop();
+                    bonjour.destroy();
+                }
+                catch (_error) {
+                    finish([], error || 'mDNS discovery failed while stopping the browser');
+                    return;
+                }
+                const result = Array.from(devices.values()).sort((left, right) => left.name.localeCompare(right.name));
+                finish(result, error);
+            };
+            const timeoutHandle = setTimeout(() => finalize(), timeoutMs);
+            browser.on('up', (service) => {
+                const host = normalizeMdnsHost(service.host || service.fqdn || '');
+                if (!host) {
+                    return;
+                }
+                const port = service.port || 1111;
+                const txt = normalizeTxtRecords(service.txt);
+                const name = txt.name || service.name || txt.id || host;
+                const hostId = getHostnameId(host);
+                const id = hostId || txt.id || undefined;
+                const key = `${host}:${port}`;
+                devices.set(key, {
+                    name,
+                    host,
+                    port,
+                    id,
+                    fqdn: service.fqdn,
+                    txt,
+                });
+            });
+            browser.on('error', (error) => {
+                clearTimeout(timeoutHandle);
+                const message = error instanceof Error ? error.message : String(error);
+                try {
+                    browser.stop();
+                    bonjour.destroy();
+                }
+                catch (_error) {
+                    finish([], `mDNS discovery failed: ${message || 'failed to stop browser after error'}`);
+                    return;
+                }
+                finalize(`mDNS discovery failed: ${message || 'discovery error'}`);
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            finish([], `mDNS discovery failed: ${message || 'discovery error'}`);
+        }
+    });
+}

package/dist/src/utilities/functions.js

@@ -39,6 +39,7 @@ const chalk = require('chalk');
 const playlistBuilder = require('./playlist-builder');
 const ff1Device = require('./ff1-device');
 const domainResolver = require('./domain-resolver');
+const logger = require('../logger');
 /**
  * Build DP1 v1.0.0 compliant playlist
  *
@@ -112,7 +113,7 @@ async function sendPlaylistToDevice(params) {
  * console.log(result.domainMap); // { 'vitalik.eth': '0x...', 'alice.tez': 'tz...' }
  */
 async function resolveDomains(params) {
-    const { domains, displayResults = true } = params;
+    const { domains, displayResults = false } = params;
     if (!domains || !Array.isArray(domains) || domains.length === 0) {
         const error = 'No domains provided for resolution';
         console.error(chalk.red(`\n${error}`));
@@ -158,7 +159,7 @@ async function verifyPlaylist(params) {
             error: 'No playlist provided for verification',
         };
     }
-    console.log(chalk.cyan('\nValidate playlist'));
+    logger.verbose(chalk.cyan('\nValidate playlist'));
     // Dynamic import to avoid circular dependency
     const playlistVerifier = await Promise.resolve().then(() => __importStar(require('./playlist-verifier')));
     const verify = playlistVerifier.verifyPlaylist ||
@@ -172,14 +173,14 @@ async function verifyPlaylist(params) {
     }
     const result = verify(playlist);
     if (result.valid) {
-        console.log(chalk.green('Playlist looks good'));
+        logger.verbose(chalk.green('Playlist looks good'));
         if (playlist.title) {
-            console.log(chalk.dim(`  Title: ${playlist.title}`));
+            logger.verbose(chalk.dim(`  Title: ${playlist.title}`));
         }
         if (playlist.items) {
-            console.log(chalk.dim(`  Items: ${playlist.items.length}`));
+            logger.verbose(chalk.dim(`  Items: ${playlist.items.length}`));
         }
-        console.log();
+        logger.verbose();
     }
     else {
         console.error(chalk.red('Playlist has issues'));
@@ -237,26 +238,7 @@ async function verifyAddresses(params) {
     }
     const result = validateAddresses(addresses);
     // Display results
-    if (result.valid) {
-        console.log(chalk.green('\n✓ All addresses are valid'));
-        result.results.forEach((r) => {
-            const typeLabel = r.type === 'ethereum'
-                ? 'Ethereum'
-                : r.type === 'ens'
-                    ? 'ENS Domain'
-                    : r.type === 'tezos-domain'
-                        ? 'Tezos Domain'
-                        : r.type === 'contract'
-                            ? 'Tezos Contract'
-                            : 'Tezos User';
-            console.log(chalk.dim(`  • ${r.address} (${typeLabel})`));
-            if (r.normalized) {
-                console.log(chalk.dim(`    Checksummed: ${r.normalized}`));
-            }
-        });
-        console.log();
-    }
-    else {
+    if (!result.valid) {
         console.error(chalk.red('\nAddress validation failed'));
         result.errors.forEach((err) => {
             console.error(chalk.red(`  • ${err}`));

package/dist/src/utilities/index.js

@@ -8,6 +8,8 @@ const feedFetcher = require('./feed-fetcher');
 const playlistBuilder = require('./playlist-builder');
 const functions = require('./functions');
 const domainResolver = require('./domain-resolver');
+const logger = require('../logger');
+const printedTokenCountKeys = new Set();
 /**
  * Initialize utilities with configuration
  *
@@ -94,7 +96,11 @@ async function queryTokensByAddress(ownerAddress, quantity, duration = 10) {
         if (typeof quantity === 'number' && selectedTokens.length > quantity) {
             selectedTokens = shuffleArray([...selectedTokens]).slice(0, quantity);
         }
-        console.log(chalk.dim(`Got ${selectedTokens.length} token(s)`));
+        const tokenCountKey = `${ownerAddress}|${quantity ?? 'all'}|${duration}`;
+        if (!printedTokenCountKeys.has(tokenCountKey)) {
+            console.log(chalk.dim(`Got ${selectedTokens.length} token(s)`));
+            printedTokenCountKeys.add(tokenCountKey);
+        }
         // Convert tokens to DP1 items
         const items = [];
         let skippedCount = 0;
@@ -147,10 +153,10 @@ async function queryRequirement(requirement, duration = 10) {
     if (type === 'query_address') {
         // Check if ownerAddress is a domain name (.eth or .tez)
         if (ownerAddress && (ownerAddress.endsWith('.eth') || ownerAddress.endsWith('.tez'))) {
-            console.log(chalk.cyan(`\nResolving domain ${ownerAddress}...`));
+            logger.verbose(chalk.cyan(`\nResolving domain ${ownerAddress}...`));
             const resolution = await domainResolver.resolveDomain(ownerAddress);
             if (resolution.resolved && resolution.address) {
-                console.log(chalk.dim(`  ${resolution.domain} → ${resolution.address}`));
+                console.log(chalk.green(`${resolution.domain} → ${resolution.address}`));
                 // Use resolved address instead of domain
                 return await queryTokensByAddress(resolution.address, quantity, duration);
             }

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

@@ -38,7 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.confirmPlaylistForSending = confirmPlaylistForSending;
 const chalk_1 = __importDefault(require("chalk"));
-const fs_1 = require("fs");
+const playlist_source_1 = require("./playlist-source");
 /**
  * Get available FF1 devices from config
  *
@@ -77,7 +77,7 @@ async function getAvailableDevices() {
  * 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} filePath - Playlist file path or URL
  * @param {string} [deviceName] - Device name (optional)
  * @returns {Promise<PlaylistSendConfirmation>} Validation result
  */
@@ -90,38 +90,57 @@ async function confirmPlaylistForSending(filePath, deviceName) {
         console.error(chalk_1.default.dim(`[DEBUG] confirmPlaylistForSending called with: filePath="${filePath}", deviceName="${deviceName}" -> "${actualDeviceName}"`));
     }
     try {
-        // Check if file exists
-        console.log(chalk_1.default.cyan(`Playlist file: ${resolvedPath}`));
-        let _fileExists = false;
+        // Load playlist from file or URL
+        console.log(chalk_1.default.cyan(`Playlist source: ${resolvedPath}`));
         let playlist;
+        let fileExists = false;
+        let loadedFrom = 'file';
         try {
-            const content = await fs_1.promises.readFile(resolvedPath, 'utf-8');
-            playlist = JSON.parse(content);
-            _fileExists = true;
-            console.log(chalk_1.default.green('File loaded'));
+            const loaded = await (0, playlist_source_1.loadPlaylistSource)(resolvedPath);
+            playlist = loaded.playlist;
+            fileExists = loaded.sourceType === 'file';
+            loadedFrom = loaded.sourceType;
+            console.log(chalk_1.default.green(`Loaded from ${loadedFrom}: ${resolvedPath}`));
         }
         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}`));
+            const message = error.message;
+            const isUrl = (0, playlist_source_1.isPlaylistSourceUrl)(resolvedPath);
+            if (isUrl) {
                 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"`,
+                    error: `Could not load playlist URL: ${resolvedPath}`,
+                    message: `${message}\n\nHint:\n  • Check the URL is reachable\n  • Confirm it returns JSON\n  • Use "send ./path/to/playlist.json" for local files`,
                 };
             }
-            throw error;
+            if (message.includes('Invalid JSON in')) {
+                return {
+                    success: false,
+                    filePath: resolvedPath,
+                    fileExists: true,
+                    playlistValid: false,
+                    error: message,
+                    message: `${message}\n\nHint:\n  • Check the JSON payload is valid DP-1 format\n  • Check local path points to a playlist file`,
+                };
+            }
+            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"`,
+            };
         }
         if (!playlist) {
             return {
                 success: false,
                 filePath: resolvedPath,
-                fileExists: true,
+                fileExists,
                 playlistValid: false,
-                error: 'Playlist file is empty',
+                error: `Playlist source is empty: ${loadedFrom}`,
             };
         }
         // Validate playlist structure

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlaylistSourceUrl = isPlaylistSourceUrl;
+exports.loadPlaylistSource = loadPlaylistSource;
+const fs_1 = require("fs");
+/**
+ * Determine whether a playlist source is an HTTP(S) URL.
+ *
+ * @param {string} source - Playlist source value
+ * @returns {boolean} Whether the value parses as http:// or https:// URL
+ */
+function isPlaylistSourceUrl(source) {
+    const trimmed = source.trim();
+    if (!trimmed) {
+        return false;
+    }
+    try {
+        const parsed = new URL(trimmed);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load a DP-1 playlist from a local file or hosted URL.
+ *
+ * @param {string} source - Playlist file path or URL
+ * @returns {Promise<LoadedPlaylist>} Loaded playlist payload with source metadata
+ * @throws {Error} When source is empty, cannot be loaded, or JSON is invalid
+ */
+async function loadPlaylistSource(source) {
+    const trimmedSource = source.trim();
+    if (!trimmedSource) {
+        throw new Error('Playlist source is required');
+    }
+    if (isPlaylistSourceUrl(trimmedSource)) {
+        const response = await fetch(trimmedSource);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch playlist URL: ${response.status} ${response.statusText}`);
+        }
+        let playlistText;
+        try {
+            playlistText = await response.text();
+        }
+        catch (error) {
+            throw new Error(`Failed to read playlist response from ${trimmedSource}: ${error.message}`);
+        }
+        try {
+            return {
+                playlist: JSON.parse(playlistText),
+                source: trimmedSource,
+                sourceType: 'url',
+            };
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON from playlist URL ${trimmedSource}: ${error.message}`);
+        }
+    }
+    let fileText;
+    try {
+        fileText = await fs_1.promises.readFile(trimmedSource, 'utf-8');
+    }
+    catch (_error) {
+        throw new Error(`Playlist file not found at ${trimmedSource}`);
+    }
+    try {
+        return {
+            playlist: JSON.parse(fileText),
+            source: trimmedSource,
+            sourceType: 'file',
+        };
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in ${trimmedSource}: ${error.message}`);
+    }
+}

package/dist/src/utilities/ssh-access.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * SSH access control for FF1 devices.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSshAccessCommand = sendSshAccessCommand;
+const logger = __importStar(require("../logger"));
+const ff1_compatibility_1 = require("./ff1-compatibility");
+/**
+ * Send an SSH access command to an FF1 device.
+ *
+ * @param {Object} params - Function parameters
+ * @param {boolean} params.enabled - Whether to enable SSH access
+ * @param {string} [params.deviceName] - Device name to target (defaults to first configured)
+ * @param {string} [params.publicKey] - SSH public key to authorize (required for enable)
+ * @param {number} [params.ttlSeconds] - Time-to-live in seconds for auto-disable
+ * @returns {Promise<Object>} Result object
+ * @returns {boolean} returns.success - Whether the command succeeded
+ * @returns {string} [returns.device] - Device host used
+ * @returns {string} [returns.deviceName] - Device name used
+ * @returns {Object} [returns.response] - Response from device
+ * @returns {string} [returns.error] - Error message if failed
+ * @throws {Error} When device configuration is invalid or missing
+ * @example
+ * // Enable SSH for 30 minutes
+ * const result = await sendSshAccessCommand({
+ *   enabled: true,
+ *   publicKey: 'ssh-ed25519 AAAAC3... user@host',
+ *   ttlSeconds: 1800,
+ * });
+ */
+async function sendSshAccessCommand({ enabled, deviceName, publicKey, ttlSeconds, }) {
+    try {
+        if (enabled && (!publicKey || !publicKey.trim())) {
+            return {
+                success: false,
+                error: 'Public key is required to enable SSH access',
+            };
+        }
+        const resolved = (0, ff1_compatibility_1.resolveConfiguredDevice)(deviceName);
+        if (!resolved.success || !resolved.device) {
+            return {
+                success: false,
+                error: resolved.error || 'FF1 device is not configured correctly',
+            };
+        }
+        const device = resolved.device;
+        const compatibility = await (0, ff1_compatibility_1.assertFF1CommandCompatibility)(device, 'sshAccess');
+        if (!compatibility.compatible) {
+            return {
+                success: false,
+                error: compatibility.error || 'FF1 OS does not support SSH access command',
+                details: compatibility.version ? `Detected version ${compatibility.version}` : undefined,
+            };
+        }
+        let apiUrl = `${device.host}/api/cast`;
+        if (device.topicID && device.topicID.trim() !== '') {
+            apiUrl += `?topicID=${encodeURIComponent(device.topicID)}`;
+            logger.debug(`Using topicID: ${device.topicID}`);
+        }
+        const request = {
+            enabled,
+        };
+        if (publicKey && publicKey.trim()) {
+            request.publicKey = publicKey.trim();
+        }
+        if (typeof ttlSeconds === 'number') {
+            request.ttlSeconds = ttlSeconds;
+        }
+        const requestBody = {
+            command: 'sshAccess',
+            request,
+        };
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (device.apiKey) {
+            headers['API-KEY'] = device.apiKey;
+        }
+        const response = await fetch(apiUrl, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.error(`SSH access request failed: ${response.status} ${response.statusText}`);
+            logger.debug(`Error details: ${errorText}`);
+            return {
+                success: false,
+                error: `Device returned error ${response.status}: ${response.statusText}`,
+                details: errorText,
+            };
+        }
+        const responseData = (await response.json());
+        logger.info('SSH access command succeeded');
+        logger.debug(`Device response: ${JSON.stringify(responseData)}`);
+        return {
+            success: true,
+            device: device.host,
+            deviceName: device.name || device.host,
+            response: responseData,
+        };
+    }
+    catch (error) {
+        logger.error(`Error sending SSH access command: ${error.message}`);
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}

package/docs/CONFIGURATION.md

@@ -94,7 +94,7 @@ DP‑1 Feed API configuration.
 
 - `feed.baseURLs` (string[]): Array of DP‑1 Feed Operator API v1 base URLs. The CLI queries all feeds in parallel.
 - Legacy support: `feed.baseURL` (string) is still accepted and normalized to an array.
-- Default: `https://feed.feralfile.com/api/v1` if not set.
+- Default: `https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1` if not set.
 - Compatibility: API v1 of the DP‑1 Feed Operator server. See the repository for endpoints and behavior: [dp1-feed](https://github.com/display-protocol/dp1-feed).
 
 Endpoints used by the CLI:
@@ -105,7 +105,7 @@ Endpoints used by the CLI:
 Environment variable alternative:
 
 ```env
-FEED_BASE_URLS=https://feed.feralfile.com/api/v1,https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1
+FEED_BASE_URLS=https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1,https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1
 ```
 
 ## ff1Devices
@@ -116,11 +116,29 @@ Configure devices you want to send playlists to.
   - `name` (string): Friendly device label. Free‑form; pick anything memorable.
   - `host` (string): Device base URL. For LAN devices, use `http://<ip>:1111`. The device typically listens on port `1111`.
 
+During `ff1 setup`, the CLI will attempt local discovery via mDNS (`_ff1._tcp`). If devices are found, you can pick one and the host will be filled in automatically. If discovery returns nothing, setup falls back to manual entry.
+
 Selection rules when sending:
 
 - If you omit `-d`, the first configured device is used.
 - If you pass `-d <name>`, the CLI matches the device by `name` (exact match). If not found, you’ll see an error listing available devices.
 
+Compatibility checks:
+
+- `send` and `ssh` perform a compatibility preflight before sending commands to FF1. The CLI gets the device version by calling `POST /api/cast` with `{ "command": "getDeviceStatus", "request": {} }` and reads `message.installedVersion` from the response.
+
+- Minimum supported FF1 OS versions:
+
+  - `send` (`displayPlaylist`): `1.0.0` or newer
+  - `ssh` (`sshAccess`): `1.0.9` or newer
+
+- If the CLI cannot get a version from the device (e.g. network or malformed response), it continues and sends the command.
+- If the detected version is below the minimum, the command fails early with an error that includes the detected version.
+
+Troubleshooting note:
+
+- If you get an unsupported-version error, update your FF1 OS and retry. If version detection seems inconsistent, check that device host and key are correct and retry with the device directly reachable.
+
 Examples:
 
 ```bash
@@ -131,7 +149,7 @@ npm run dev -- send playlist.json
 npm run dev -- send playlist.json -d "Living Room Display"
 ```
 
-Minimal `config.json` example (selected fields):
+ Minimal `config.json` example (selected fields):
 
 ```json
 {
@@ -149,9 +167,7 @@ Minimal `config.json` example (selected fields):
     "privateKey": "your_ed25519_private_key_hex_or_base64_here"
   },
   "feed": {
-    "baseURLs": [
-      "https://feed.feralfile.com/api/v1"
-    ]
+    "baseURLs": ["https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1"]
   },
   "ff1Devices": {
     "devices": [
@@ -174,5 +190,3 @@ npm run dev -- config validate
 ```
 
 If configuration is invalid, the CLI prints actionable errors and a non‑zero exit code.
-
-

package/docs/EXAMPLES.md

@@ -25,6 +25,8 @@ npm run dev -- chat "Get 3 items from Social Codes and 2 from 0xdef" -v
 npm run dev -- chat "your request" --model grok
 npm run dev -- chat "your request" --model gpt
 npm run dev -- chat "your request" --model gemini
+
+# Model names must match keys in config.json under `models`.
 ```
 
 ## Deterministic Build (no AI)
@@ -67,7 +69,7 @@ The CLI recognizes publishing keywords like "publish", "publish to my feed", "pu
 npm run dev -- chat "Build playlist from Ethereum contract 0xb932a70A57673d89f4acfFBE830E8ed7f75Fb9e0 with tokens 52932 and 52457; publish to my feed" -o playlist.json -v
 
 # With feed selection (if multiple servers configured)
-# The CLI will ask: "Which feed server? 1) https://feed.feralfile.com/api/v1 2) http://localhost:8787"
+# The CLI will ask: "Which feed server? 1) https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1 2) http://localhost:8787"
 npm run dev -- chat "Get 3 from Social Codes and publish to feed" -v
 
 # Publish existing playlist (defaults to ./playlist.json)
@@ -117,12 +119,14 @@ Output shows:
 ```bash
 # Validate playlist
 npm run dev -- validate playlist.json
+npm run dev -- validate "https://cdn.example.com/playlist.json"
 
 # Sign playlist
 npm run dev -- sign playlist.json -o signed.json
 
 # Send to device
 npm run dev -- send playlist.json -d "Living Room Display"
+npm run dev -- send "https://cdn.example.com/playlist.json" -d "Living Room Display"
 ```
 
 ## Publish to Feed Server