@feralfile/cli 2.10.1 → 4.0.0

package/dist/src/config.js

@@ -11,6 +11,8 @@ exports.getPlaylistConfig = getPlaylistConfig;
 exports.getFeedConfig = getFeedConfig;
 exports.getFF1DeviceConfig = getFF1DeviceConfig;
 exports.getFF1RelayerConfig = getFF1RelayerConfig;
+exports.getSupportLogsConfig = getSupportLogsConfig;
+exports.getTokenSourceConfig = getTokenSourceConfig;
 exports.validateConfig = validateConfig;
 exports.createSampleConfig = createSampleConfig;
 const fs_1 = __importDefault(require("fs"));
@@ -18,6 +20,45 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const playlist_signing_role_1 = require("./utilities/playlist-signing-role");
 const config_placeholders_1 = require("./utilities/config-placeholders");
+/**
+ * The feed server used when neither config.json nor FEED_BASE_URLS names one. It replaced
+ * dp1-feed-operator-api-prod.autonomy-system.workers.dev, a deleted worker whose zone belongs to
+ * an account being retired: a default must never name a host someone else could register.
+ * DEFAULT_FF1_RELAYER_URL below is in the same zone but still live; the ff-cli release after
+ * the legacy relayer shutdown turns it off (ffos-user docs/ff1-control-v1.md §15.4).
+ */
+const DEFAULT_FEED_BASE_URL = 'https://feed.feralfile.com/api/v1';
+/**
+ * The deleted worker ff-cli 3.0.0 named. Its `setup` and `config init` copied it into every
+ * config.json they wrote, and an explicit feed wins over the default, so a configured URL on
+ * this host is read as feed.feralfile.com (path kept) instead: same operator, same API.
+ */
+const RETIRED_FEED_HOST = 'dp1-feed-operator-api-prod.autonomy-system.workers.dev';
+const RETIRED_FEED_REPLACEMENT_ORIGIN = 'https://feed.feralfile.com';
+let retiredFeedNoted = false;
+/**
+ * replaceRetiredFeedUrl maps a feed URL on RETIRED_FEED_HOST to feed.feralfile.com, keeping its
+ * path, and notes it once per run on stderr (stdout may be a script's JSON). Any other URL,
+ * including an unparseable one, is returned unchanged.
+ */
+function replaceRetiredFeedUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return url;
+    }
+    if (parsed.hostname.toLowerCase() !== RETIRED_FEED_HOST) {
+        return url;
+    }
+    const replaced = `${RETIRED_FEED_REPLACEMENT_ORIGIN}${parsed.pathname.replace(/\/$/, '')}${parsed.search}`;
+    if (!retiredFeedNoted) {
+        retiredFeedNoted = true;
+        console.error(`Note: ${url} is a retired feed server; using ${replaced}. Update the feed in config.json or FEED_BASE_URLS to stop this note.`);
+    }
+    return replaced;
+}
 function getConfigPaths() {
     const localPath = path_1.default.join(process.cwd(), 'config.json');
     const configBase = process.env.XDG_CONFIG_HOME || path_1.default.join(os_1.default.homedir(), '.config');
@@ -43,7 +84,7 @@ function loadConfig() {
         feed: {
             baseURLs: process.env.FEED_BASE_URLS
                 ? process.env.FEED_BASE_URLS.split(',')
-                : ['https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1'],
+                : [DEFAULT_FEED_BASE_URL],
         },
     };
     // Try to load config.json if it exists
@@ -188,10 +229,13 @@ function getFeedConfig() {
     const config = getConfig();
     // Check for new feedServers format first
     if (config.feedServers && Array.isArray(config.feedServers) && config.feedServers.length > 0) {
-        const baseURLs = config.feedServers.map((server) => server.baseUrl);
+        const servers = config.feedServers.map((server) => ({
+            ...server,
+            baseUrl: replaceRetiredFeedUrl(server.baseUrl),
+        }));
         return {
-            baseURLs,
-            servers: config.feedServers,
+            baseURLs: servers.map((server) => server.baseUrl),
+            servers,
         };
     }
     // Fall back to legacy feed format
@@ -206,10 +250,10 @@ function getFeedConfig() {
     }
     else {
         // Default feed URL
-        urls = ['https://dp1-feed-operator-api-prod.autonomy-system.workers.dev/api/v1'];
+        urls = [DEFAULT_FEED_BASE_URL];
     }
     return {
-        baseURLs: urls,
+        baseURLs: urls.map(replaceRetiredFeedUrl),
     };
 }
 /**
@@ -230,6 +274,12 @@ function getFF1DeviceConfig() {
     };
 }
 const DEFAULT_FF1_RELAYER_URL = 'https://tv-cast-coordination.autonomy-system.workers.dev';
+/**
+ * The production relay v2 origin. Relay v2 runs on its own Worker, not on the
+ * legacy relayer's origin, and must keep working after the legacy host is
+ * retired (ffos-user docs/ff1-control-v1.md §15.3, §15.4).
+ */
+const DEFAULT_FF1_RELAY_V2_ENDPOINT = 'wss://relayer.feralfile.io';
 /**
  * Get the FF1 relayer endpoint using repository config priority.
  *
@@ -270,12 +320,200 @@ function resolveFF1RelayerConfig(config) {
     if (!['http:', 'https:'].includes(parsed.protocol)) {
         throw new Error('ff1Relayer.baseUrl must be a valid HTTP(S) URL');
     }
+    const v2 = resolveV2Endpoint(fields.v2Endpoint, parsed);
     const apiKey = (fields.apiKey || process.env.FF1_RELAYER_API_KEY)?.trim();
     return {
         baseUrl,
         apiKey: apiKey || undefined,
+        ...(v2.endpoint ? { v2Endpoint: v2.endpoint } : {}),
+        ...(v2.endpoint && v2.explicit ? { v2Explicit: true } : {}),
     };
 }
+const DEFAULT_SUPPORT_LOGS_URL = 'https://support-logs.feralfile.com';
+/**
+ * getSupportLogsConfig returns the support-logs origin `ff-cli report` posts to.
+ *
+ * `config.json` (`supportLogs.baseUrl`) wins over FF_SUPPORT_LOGS_URL, which
+ * wins over the production default, the same order as `ff1Relayer.baseUrl`.
+ * The override is for tests and staging. It does not move the Art Computer's
+ * log upload: FF OS posts its logs to the support-logs its firmware names.
+ */
+function getSupportLogsConfig() {
+    return resolveSupportLogsConfig(getConfig());
+}
+/** Resolve and validate the effective support-logs configuration. */
+function resolveSupportLogsConfig(config) {
+    const configured = config.supportLogs;
+    if (configured !== undefined &&
+        (configured === null || typeof configured !== 'object' || Array.isArray(configured))) {
+        throw new Error('supportLogs must be an object');
+    }
+    const baseUrl = configured?.baseUrl;
+    if (baseUrl !== undefined && typeof baseUrl !== 'string') {
+        throw new Error('supportLogs.baseUrl must be a string');
+    }
+    const value = (baseUrl ||
+        process.env.FF_SUPPORT_LOGS_URL ||
+        DEFAULT_SUPPORT_LOGS_URL)
+        .trim()
+        .replace(/\/+$/, '');
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error('supportLogs.baseUrl must be a valid HTTP(S) URL');
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol)) {
+        throw new Error('supportLogs.baseUrl must be a valid HTTP(S) URL');
+    }
+    return { baseUrl: value };
+}
+const TOKEN_SOURCES = ['raster', 'indexer'];
+const DEFAULT_TOKEN_SOURCE = 'indexer';
+const DEFAULT_IPFS_GATEWAY_FERAL_FILE = 'https://ipfs.feralfile.com/ipfs/';
+const DEFAULT_IPFS_GATEWAY = 'https://ipfs.filebase.io/ipfs/';
+/**
+ * Get the token source selection using repository config priority.
+ *
+ * `config.json` wins over environment variables, which win over the defaults.
+ * The Feral File indexer is the default vendor; `raster` is opt-in while
+ * Raster's data bugs (feral-file#3546) are open. There is no fallback between
+ * the two at runtime: one vendor answers a whole run.
+ */
+function getTokenSourceConfig() {
+    return resolveTokenSourceConfig(getConfig());
+}
+/** Resolve and validate the effective token source configuration. */
+function resolveTokenSourceConfig(config) {
+    const source = resolveTokenSourceName(config);
+    const gateways = resolveIpfsGatewayFields(config);
+    return {
+        source,
+        ipfsGateways: {
+            feralFile: normalizeIpfsGateway(gateways.feralFile ||
+                process.env.IPFS_GATEWAY_FERAL_FILE ||
+                DEFAULT_IPFS_GATEWAY_FERAL_FILE, 'ipfsGateways.feralFile'),
+            default: normalizeIpfsGateway(gateways.default || process.env.IPFS_GATEWAY_DEFAULT || DEFAULT_IPFS_GATEWAY, 'ipfsGateways.default'),
+        },
+    };
+}
+/** resolveTokenSourceName picks the vendor name, rejecting anything outside TOKEN_SOURCES. */
+function resolveTokenSourceName(config) {
+    const configured = config.tokenSource;
+    if (configured !== undefined && typeof configured !== 'string') {
+        throw new Error(`tokenSource must be one of: ${TOKEN_SOURCES.join(', ')}`);
+    }
+    const candidate = (configured || process.env.FF_TOKEN_SOURCE || '')
+        .trim()
+        .toLowerCase();
+    if (!candidate) {
+        return DEFAULT_TOKEN_SOURCE;
+    }
+    if (!TOKEN_SOURCES.includes(candidate)) {
+        throw new Error(`tokenSource must be one of: ${TOKEN_SOURCES.join(', ')}`);
+    }
+    return candidate;
+}
+/** resolveIpfsGatewayFields type-checks the `ipfsGateways` block without resolving defaults. */
+function resolveIpfsGatewayFields(config) {
+    const configured = config.ipfsGateways;
+    if (configured === undefined) {
+        return {};
+    }
+    if (configured === null || typeof configured !== 'object' || Array.isArray(configured)) {
+        throw new Error('ipfsGateways must be an object');
+    }
+    const fields = configured;
+    for (const key of ['feralFile', 'default']) {
+        if (fields[key] !== undefined && typeof fields[key] !== 'string') {
+            throw new Error(`ipfsGateways.${key} must be a string`);
+        }
+    }
+    return { feralFile: fields.feralFile, default: fields.default };
+}
+/**
+ * normalizeIpfsGateway validates a gateway and returns it in `https://host/ipfs/` form.
+ *
+ * A bare origin is accepted because that is how gateways are usually quoted;
+ * the `/ipfs/` path is what a CID is appended to, so it is added when absent
+ * and a trailing slash is guaranteed so callers can concatenate.
+ */
+function normalizeIpfsGateway(value, label) {
+    let parsed;
+    try {
+        parsed = new URL(value.trim());
+    }
+    catch {
+        throw new Error(`${label} must be a valid HTTP(S) URL`);
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol)) {
+        throw new Error(`${label} must be a valid HTTP(S) URL`);
+    }
+    const path = parsed.pathname.replace(/\/+$/, '');
+    parsed.pathname = path.endsWith('/ipfs') ? `${path}/` : `${path}/ipfs/`;
+    parsed.search = '';
+    parsed.hash = '';
+    return parsed.toString();
+}
+/**
+ * resolveV2Endpoint picks the relay v2 origin (ffos-user docs/ff1-control-v1.md
+ * §10). An explicit `ff1Relayer.v2Endpoint` or FF1_RELAY_V2_ENDPOINT wins; an
+ * empty string turns v2 off. Otherwise the production legacy relayer maps to
+ * the production relay v2 Worker (DEFAULT_FF1_RELAY_V2_ENDPOINT), which lives
+ * on its own origin. A custom HTTPS legacy relayer (a development Worker that
+ * serves both `/api` and `/v2/channels/…`) still uses its own origin. A
+ * custom plain-HTTP or path-bearing legacy relayer gets no v2 unless one is
+ * configured.
+ *
+ * The derived default is only a pairing default for commands: during the
+ * rollout most FF1s are not on v2, and a stranger's ACK on the device channel
+ * would turn a command that the legacy topic could have delivered into an
+ * ambiguous one. secure-transport therefore sends commands on a derived
+ * endpoint only to an FF1 that advertised `relayV2` in a verified status.
+ *
+ * @param configured - The `ff1Relayer.v2Endpoint` value, if any
+ * @param baseUrl - The validated legacy relayer URL
+ * @returns The v2 origin (undefined when v2 is off) and whether it was configured
+ * @throws {Error} When a configured endpoint is not an acceptable origin
+ */
+function resolveV2Endpoint(configured, baseUrl) {
+    const value = configured ?? process.env.FF1_RELAY_V2_ENDPOINT;
+    if (value === undefined) {
+        if (baseUrl.origin === new URL(DEFAULT_FF1_RELAYER_URL).origin) {
+            return { endpoint: DEFAULT_FF1_RELAY_V2_ENDPOINT, explicit: false };
+        }
+        const bare = !baseUrl.username && !baseUrl.password && !baseUrl.search && !baseUrl.hash;
+        const derived = baseUrl.protocol === 'https:' && bare && ['', '/'].includes(baseUrl.pathname);
+        return { endpoint: derived ? baseUrl.origin : undefined, explicit: false };
+    }
+    if (typeof value !== 'string') {
+        throw new Error('ff1Relayer.v2Endpoint must be a string');
+    }
+    if (value.trim() === '') {
+        return { explicit: true };
+    }
+    let endpoint;
+    try {
+        endpoint = new URL(value);
+    }
+    catch {
+        throw new Error('Invalid ff1Relayer.v2Endpoint');
+    }
+    const loopback = ['localhost', '127.0.0.1', '[::1]'].includes(endpoint.hostname);
+    if (!['https:', 'wss:'].includes(endpoint.protocol) &&
+        !(['http:', 'ws:'].includes(endpoint.protocol) && loopback)) {
+        throw new Error('ff1Relayer.v2Endpoint requires WSS/HTTPS outside loopback');
+    }
+    if (endpoint.username ||
+        endpoint.password ||
+        endpoint.search ||
+        endpoint.hash ||
+        !['', '/'].includes(endpoint.pathname)) {
+        throw new Error('Invalid ff1Relayer.v2Endpoint');
+    }
+    return { endpoint: value, explicit: true };
+}
 /**
  * Validate configuration
  *
@@ -341,6 +579,18 @@ function validateConfig() {
         catch (error) {
             errors.push(error.message);
         }
+        try {
+            resolveTokenSourceConfig(config);
+        }
+        catch (error) {
+            errors.push(error.message);
+        }
+        try {
+            resolveSupportLogsConfig(config);
+        }
+        catch (error) {
+            errors.push(error.message);
+        }
         return {
             valid: errors.length === 0,
             errors,

package/dist/src/main.js

@@ -4,6 +4,7 @@
  * Builds DP-1 playlists deterministically from structured parameters.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIREMENT_TYPES = void 0;
 exports.validateRequirements = validateRequirements;
 exports.applyPlaylistDefaults = applyPlaylistDefaults;
 exports.buildPlaylistDirect = buildPlaylistDirect;
@@ -18,10 +19,20 @@ process.emitWarning = function (warning, type, ctor) {
     }
     return originalEmitWarning.apply(this, [warning, type, ctor]);
 };
-const config_1 = require("./config");
 // Lazy load utilities to avoid circular dependencies
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const getUtilities = () => require('./utilities');
+/**
+ * REQUIREMENT_TYPES lists every requirement `build` accepts, in the order
+ * `build --help` documents them. Kept beside validateRequirements so a new
+ * branch there and this list change together.
+ */
+exports.REQUIREMENT_TYPES = [
+    'build_playlist',
+    'query_address',
+    'fetch_feed',
+    'feral_file_artwork',
+];
 /**
  * Validate and apply constraints to requirements
  *
@@ -103,7 +114,8 @@ function validateRequirements(requirements) {
                 };
             }
         }
-        throw new Error(`Requirement ${index + 1}: invalid type "${req.type}"`);
+        throw new Error(`Requirement ${index + 1}: invalid type "${req.type}". ` +
+            `Valid types: ${exports.REQUIREMENT_TYPES.join(', ')} (see ff-cli build --help).`);
     });
 }
 /**
@@ -140,8 +152,5 @@ async function buildPlaylistDirect(params, options = {}) {
     const requirements = validateRequirements(params.requirements);
     const playlistSettings = applyPlaylistDefaults(params.playlistSettings);
     const utilities = getUtilities();
-    const config = (0, config_1.getConfig)();
-    // Initialize utilities with config (indexer endpoint, API key, etc.)
-    utilities.initializeUtilities(config);
     return await utilities.buildPlaylistDirect({ requirements, playlistSettings }, options);
 }