@feralfile/cli 1.5.0 → 2.0.0

package/dist/src/utilities/marketplace-url.js

@@ -26,6 +26,7 @@ exports.parseOpenSea = parseOpenSea;
 exports.parseSuperRare = parseSuperRare;
 exports.parseNeort = parseNeort;
 exports.parseVerse = parseVerse;
+exports.parseRaster = parseRaster;
 exports.parseFeralFile = parseFeralFile;
 const ETH_ADDR = /^0x[a-fA-F0-9]{40}$/;
 const TEZOS_ADDR = /^(tz1|tz2|tz3)[1-9A-HJ-NP-Za-km-z]{33}$/;
@@ -101,6 +102,9 @@ function parseMarketplaceUrl(url) {
     if (host === 'verse.works' || host.endsWith('.verse.works')) {
         return parseVerse(url);
     }
+    if (host === 'raster.art' || host.endsWith('.raster.art')) {
+        return parseRaster(url);
+    }
     return null;
 }
 /**
@@ -382,6 +386,27 @@ function parseVerse(url) {
             '/items/ethereum/{contract}/{tokenId} or /series/{slug}.',
     };
 }
+/**
+ * Raster URL forms (raster.art):
+ *   raster.art/artwork/{slug}   — artwork (series) detail page
+ *
+ * Unlike the other marketplaces, Raster is already the find flow's backend
+ * resolver — so a Raster URL resolves to an artwork by slug via
+ * `artworkBySlug` and (crucially) builds DP-1 items straight from Raster's
+ * own `media.contentUrl`, bypassing the FF indexer the way Neort does. This
+ * is what lets Raster-minted tokens (which the FF indexer doesn't carry)
+ * build a verifiable playlist without `--skip-verify`.
+ */
+function parseRaster(url) {
+    const m = /^\/artwork\/([A-Za-z0-9][A-Za-z0-9_-]*)\/?$/.exec(url.pathname);
+    if (m) {
+        return { kind: 'raster-artwork', slug: m[1] };
+    }
+    return {
+        kind: 'unsupported',
+        reason: `Raster URL not recognized: ${url.pathname}. Expected /artwork/{slug}.`,
+    };
+}
 /**
  * Feral File URL forms (source of truth: feralfile-client app-routing
  * + collection-routing modules):

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

@@ -21,18 +21,43 @@ function isTimeBasedMedia(mimeType, sourceUrl) {
     const candidates = [String(mimeType || '').toLowerCase(), detectMimeType(sourceUrl)];
     return candidates.some((mime) => mime.startsWith('video/') || mime.startsWith('audio/'));
 }
+/**
+ * isInteractiveWeb reports whether an item is an interactive web page (HTML).
+ *
+ * Such sources have no intrinsic runtime AND no end-of-stream event, so they
+ * are timed differently from both video/audio (which end) and static images
+ * (which need a display duration): they play open-ended. The FF1 player
+ * renders these in a sandboxed iframe.
+ *
+ * Mirrors isTimeBasedMedia's two-signal approach: an explicit `text/html`
+ * MIME hint or a `.html`/`.htm` URL extension qualifies.
+ *
+ * @param {string} [mimeType] - MIME type hint, if any
+ * @param {string} [sourceUrl] - Item source URL, used as an extension fallback
+ * @returns {boolean} True when the source is an interactive HTML page
+ */
+function isInteractiveWeb(mimeType, sourceUrl) {
+    const candidates = [String(mimeType || '').toLowerCase(), detectMimeType(sourceUrl)];
+    return candidates.some((mime) => mime.startsWith('text/html'));
+}
 /**
  * applyItemTiming sets a DP1 item's playback timing per DP-1 §4.1.
  *
  * Invariant this function owns: an explicit numeric `duration` always wins
- * and is stamped as-is. When `duration` is undefined/null ("auto"), a
- * time-based source (video/audio) gets NO duration and `display.loop: false`,
- * so a conformant player MUST advance at end-of-stream — the media plays its
- * natural length. Static and code-based sources fall back to the configured
- * `defaultDuration` because they have no intrinsic runtime to play out.
+ * and is stamped as-is. When `duration` is undefined/null ("auto"):
+ *   - a time-based source (video/audio) gets NO duration and
+ *     `display.loop: false`, so a conformant player MUST advance at
+ *     end-of-stream — the media plays its natural length;
+ *   - an interactive web page (HTML) gets NO duration either, but for the
+ *     opposite reason: it has no end-of-stream event, so a conformant player
+ *     parks on it indefinitely (the generative/interactive art keeps running);
+ *   - static and code-based sources fall back to the configured
+ *     `defaultDuration` because they have no intrinsic runtime to play out.
  *
  * Do not re-introduce an unconditional duration here: stamping a default on
- * video items silently truncates or pads them (the bug this fixed).
+ * video items silently truncates or pads them, and stamping one on an HTML
+ * page cuts the artwork off and restarts it every `defaultDuration` seconds
+ * (the bugs this guards against).
  *
  * @param {Object} item - DP1 playlist item (mutated in place)
  * @param {Object} mediaHints - Media signals for the time-based check
@@ -50,6 +75,11 @@ function applyItemTiming(item, mediaHints = {}, duration) {
         item.display = { ...(item.display || {}), loop: false };
         return item;
     }
+    if (isInteractiveWeb(mediaHints.mimeType, mediaHints.sourceUrl)) {
+        // No duration: an open-ended interactive page should play until the
+        // playlist advances for another reason, not on a fixed timer.
+        return item;
+    }
     item.duration = getDefaultStaticDuration();
     return item;
 }
@@ -496,20 +526,24 @@ function validateDP1Playlist(playlist) {
     };
 }
 /**
- * Detect MIME type from URL or file extension
+ * Detect MIME type from a URL or file extension.
  *
- * Analyzes URL to determine appropriate MIME type for media content.
- * Supports images, videos, audio, and 3D models.
+ * Maps known media/web extensions to a MIME type. Returns '' (empty) when the
+ * extension is unknown or absent — the type is genuinely undetermined, and
+ * callers decide the fallback. (Do NOT default to 'image/png': that silently
+ * misclassified HTML pages and extensionless URLs as static images, stamping
+ * them with a display duration that cut interactive artworks off.)
  *
- * @param {string} url - Media URL
- * @returns {string} MIME type
+ * @param {string} url - Media or page URL
+ * @returns {string} MIME type, or '' when undetermined
  * @example
- * const mimeType = detectMimeType('https://example.com/image.png');
- * // Returns: 'image/png'
+ * detectMimeType('https://example.com/image.png'); // 'image/png'
+ * detectMimeType('https://example.com/art.html');  // 'text/html'
+ * detectMimeType('https://example.com/output/abc'); // ''
  */
 function detectMimeType(url) {
     if (!url) {
-        return 'image/png';
+        return '';
     }
     const extension = url.split('.').pop()?.toLowerCase().split('?')[0];
     const mimeTypes = {
@@ -519,6 +553,8 @@ function detectMimeType(url) {
         gif: 'image/gif',
         webp: 'image/webp',
         svg: 'image/svg+xml',
+        html: 'text/html',
+        htm: 'text/html',
         mp4: 'video/mp4',
         webm: 'video/webm',
         mp3: 'audio/mpeg',
@@ -526,7 +562,7 @@ function detectMimeType(url) {
         glb: 'model/gltf-binary',
         gltf: 'model/gltf+json',
     };
-    return mimeTypes[extension] || 'image/png';
+    return mimeTypes[extension] || '';
 }
 /**
  * Build a single DP1 playlist item from a URL
@@ -536,6 +572,10 @@ function detectMimeType(url) {
  *   (video/audio URLs play their natural length per DP-1 §4.1)
  * @param {Object} [options] - Optional configuration
  * @param {string} [options.title] - Optional item title override
+ * @param {string} [options.mimeType] - Source media type hint for timing
+ *   (DP-1 §4.1). Needed when the URL has no file extension to detect from —
+ *   e.g. extensionless IPFS gateway URLs, where without this hint a video
+ *   would be misclassified as a static image and stamped a fixed duration.
  * @returns {Object} DP1 playlist item
  */
 function buildUrlItem(url, duration, options = {}) {
@@ -580,7 +620,13 @@ function buildUrlItem(url, duration, options = {}) {
             margin: 0,
         },
     };
-    return applyItemTiming(item, { sourceUrl }, duration);
+    // A URL handed to `play` that isn't a recognized media file is treated as an
+    // interactive web page: the FF1 renders unknown URLs in a sandboxed iframe,
+    // so an explicit caller hint aside, "unknown" means web, not static image.
+    // This routes such items through the open-ended (no-duration) timing path
+    // instead of the static-image default.
+    const mimeHint = options.mimeType || (detectMimeType(sourceUrl) === '' ? 'text/html' : undefined);
+    return applyItemTiming(item, { sourceUrl, mimeType: mimeHint }, duration);
 }
 module.exports = {
     convertTokenToDP1Item,
@@ -591,6 +637,7 @@ module.exports = {
     validateDP1Playlist,
     detectMimeType,
     isTimeBasedMedia,
+    isInteractiveWeb,
     applyItemTiming,
     buildUrlItem,
 };

package/dist/src/utilities/raster-client.js

@@ -58,6 +58,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveTokenToArtwork = resolveTokenToArtwork;
+exports.resolveSlugToArtwork = resolveSlugToArtwork;
 exports.resolveAddressToArtist = resolveAddressToArtist;
 exports.listArtworkTokens = listArtworkTokens;
 exports.listArtistArtworks = listArtistArtworks;
@@ -150,6 +151,30 @@ async function resolveTokenToArtwork(chain, contract, tokenId) {
         artists: (artwork.artists ?? []).map(toRasterArtist),
     };
 }
+/**
+ * Resolve a `raster.art/artwork/{slug}` URL to its artwork (series) summary.
+ *
+ * One round trip via `artworkBySlug`. Returns `null` when the slug is
+ * unknown (Raster models not-found as a null query field, not an HTTP 404).
+ */
+async function resolveSlugToArtwork(slug) {
+    const data = await rasterQuery(`query ResolveSlug($slug: String!) {
+      artworkBySlug(slug: $slug) {
+        id
+        title
+        artists { id name slug }
+      }
+    }`, { slug });
+    const artwork = data.artworkBySlug;
+    if (!artwork) {
+        return null;
+    }
+    return {
+        artworkId: artwork.id,
+        title: artwork.title,
+        artists: (artwork.artists ?? []).map(toRasterArtist),
+    };
+}
 /**
  * Resolve a wallet address to the Raster artist who claims it.
  *
@@ -180,7 +205,7 @@ async function listArtworkTokens(artworkId, options = {}) {
     const data = await rasterQuery(`query ArtworkTokens($id: ID!, $first: Int, $after: String) {
       artwork(id: $id) {
         tokens(first: $first, after: $after) {
-          nodes { chainId contractAddress tokenId }
+          nodes { chainId contractAddress tokenId media { contentUrl contentType previewType } }
           pageInfo { hasNextPage endCursor }
         }
       }
@@ -200,6 +225,10 @@ async function listArtworkTokens(artworkId, options = {}) {
             chain,
             contractAddress: raw.contractAddress,
             tokenId: raw.tokenId,
+            mediaUrl: raw.media?.contentUrl ?? null,
+            // Prefer a real MIME (`contentType`) when Raster populates it; today it
+            // is usually empty, so fall back to the category-prefixed `previewType`.
+            mediaType: raw.media?.contentType || raw.media?.previewType || null,
         });
     }
     const { hasNextPage, endCursor } = data.artwork.tokens.pageInfo;

package/docs/CONFIGURATION.md

@@ -21,35 +21,10 @@ npm run dev -- config show
 
 ## Top‑level fields
 
-- **defaultModel** (string)
-  - The default AI model key to use. Must match a key under `models`.
-  - Used by orchestration to pick API, timeouts, and model identifier.
-
 - **defaultDuration** (number, seconds)
   - Default per‑item display duration for media without an intrinsic runtime (images, code-based works). Falls back to 10s when unset.
   - Does NOT apply to video/audio items: with no explicit duration those are emitted without `duration` and with `display.loop: false`, so a DP-1 player advances at end-of-stream (§4.1) — the media plays its natural length.
 
-## models
-
-Each key under `models` defines a model configuration used by the AI orchestrator.
-
-- `<modelName>.apiKey` (string): API key for the provider.
-- `<modelName>.baseURL` (string): Base API URL.
-- `<modelName>.model` (string): Model identifier (e.g., `grok-beta`, `gpt-4o`).
-- `<modelName>.availableModels` (string[], optional): Display/help only.
-- `<modelName>.timeout` (number, ms): HTTP timeout for requests.
-- `<modelName>.maxRetries` (number): Retry count for requests.
-- `<modelName>.temperature` (number): Generation temperature.
-- `<modelName>.maxTokens` (number): Token cap.
-- `<modelName>.supportsFunctionCalling` (boolean): Must be true; otherwise the CLI rejects the model.
-
-Environment variable helpers:
-
-- Anthropic (Claude): `ANTHROPIC_API_KEY`
-- Grok: `GROK_API_KEY`, `GROK_MODEL`, `GROK_API_BASE_URL`
-- OpenAI: `OPENAI_API_KEY`
-- Gemini: `GEMINI_API_KEY`
-
 ## browser
 
 Optional settings used where headless/browser‑like behavior is needed.
@@ -182,15 +157,6 @@ Minimal `config.json` example (selected fields):
 
 ```json
 {
-  "defaultModel": "claude",
-  "models": {
-    "claude": {
-      "apiKey": "sk-ant-your-api-key-here",
-      "baseURL": "https://api.anthropic.com/v1/",
-      "model": "claude-sonnet-4-6",
-      "supportsFunctionCalling": true
-    }
-  },
   "defaultDuration": 10,
   "playlist": {
     "privateKey": "your_ed25519_private_key_hex_or_base64_here",