@feralfile/cli 3.0.0 → 4.0.0

package/dist/src/config.js

@@ -11,6 +11,7 @@ exports.getPlaylistConfig = getPlaylistConfig;
 exports.getFeedConfig = getFeedConfig;
 exports.getFF1DeviceConfig = getFF1DeviceConfig;
 exports.getFF1RelayerConfig = getFF1RelayerConfig;
+exports.getSupportLogsConfig = getSupportLogsConfig;
 exports.getTokenSourceConfig = getTokenSourceConfig;
 exports.validateConfig = validateConfig;
 exports.createSampleConfig = createSampleConfig;
@@ -19,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');
@@ -44,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
@@ -189,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
@@ -207,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),
     };
 }
 /**
@@ -231,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.
  *
@@ -271,12 +320,55 @@ 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/';
@@ -364,6 +456,64 @@ function normalizeIpfsGateway(value, label) {
     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
  *
@@ -435,6 +585,12 @@ function validateConfig() {
         catch (error) {
             errors.push(error.message);
         }
+        try {
+            resolveSupportLogsConfig(config);
+        }
+        catch (error) {
+            errors.push(error.message);
+        }
         return {
             valid: errors.length === 0,
             errors,