ff1-cli 1.0.2 → 1.0.3

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

@@ -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://dp1-feed-operator-api-prod.autonomy-system.workers.dev/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

@@ -23,8 +23,10 @@ npm run dev -- chat "Get 3 items from Social Codes and 2 from 0xdef" -v
 
 # Switch model
 npm run dev -- chat "your request" --model grok
-npm run dev -- chat "your request" --model chatgpt
+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)
@@ -44,7 +46,7 @@ cat examples/params-example.json | npm run dev -- build -o playlist.json
 npm run dev -- chat "Build a playlist of my Tezos works from address tz1... plus 3 from Social Codes" -v -o playlist.json
 
 # Switch model if desired
-npm run dev -- chat "Build playlist from Ethereum address 0x... and 2 from Social Codes" --model chatgpt -v
+npm run dev -- chat "Build playlist from Ethereum address 0x... and 2 from Social Codes" --model gpt -v
 ```
 
 ### One‑shot complex prompt
@@ -92,18 +94,21 @@ npm run dev -- chat "Get 5 from Social Codes, shuffle, display on 'Living Room',
 ### How It Works
 
 **Mode 1: Build and Publish** (when sources are mentioned)
+
 1. Intent parser detects "publish" keywords with sources/requirements
 2. Calls `get_feed_servers` to retrieve configured servers
 3. If 1 server → uses it automatically; if 2+ servers → asks user to pick
 4. Builds playlist → verifies → publishes automatically
 
 **Mode 2: Publish Existing File** (e.g., "publish playlist")
+
 1. Intent parser detects "publish playlist" or similar phrases
 2. Calls `get_feed_servers` to retrieve configured servers
 3. If 1 server → uses it automatically; if 2+ servers → asks user to pick
 4. Publishes the playlist from `./playlist.json` (or specified path)
 
 Output shows:
+
 - Playlist build progress (Mode 1 only)
 - Device sending (if requested): `✓ Sent to device: Living Room`
 - Publishing status: `✓ Published to feed server`
@@ -114,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
@@ -187,18 +194,21 @@ Select server (0-based index): 0
 ### Error Handling
 
 **Validation failed:**
+
 ```
 ❌ Failed to publish playlist
    Playlist validation failed: dpVersion: Required; id: Required
 ```
 
 **File not found:**
+
 ```
 ❌ Failed to publish playlist
    Playlist file not found: /path/to/playlist.json
 ```
 
 **API error:**
+
 ```
 ❌ Failed to publish playlist
    Failed to publish: {"error":"unauthorized","message":"Invalid API key"}
@@ -233,7 +243,6 @@ npm run dev -- config show
 npm run dev -- config init
 ```
 
-
 ### Natural‑language one‑shot examples (proven)
 
 - **ETH contract + token IDs (shuffle/mix, generic device)**
@@ -328,4 +337,4 @@ npm run dev -- config init
     ```bash
     npm run dev -- chat "Compose a playlist from reas.eth (3 items); send to device" -o playlist-generic-device.json -v
     npm run dev -- chat "Compose a playlist from reas.eth (3 items); send to 'Living Room'" -o playlist-named-device.json -v
-    ```
+    ```

package/docs/README.md

@@ -40,7 +40,7 @@ See the full configuration reference here: `./CONFIGURATION.md`.
       "model": "grok-beta",
       "supportsFunctionCalling": true
     },
-    "chatgpt": {
+    "gpt": {
       "apiKey": "sk-your-openai-key-here",
       "baseURL": "https://api.openai.com/v1",
       "model": "gpt-4o",
@@ -49,7 +49,7 @@ See the full configuration reference here: `./CONFIGURATION.md`.
     "gemini": {
       "apiKey": "your-gemini-key-here",
       "baseURL": "https://generativelanguage.googleapis.com/v1beta/openai/",
-      "model": "gemini-2.0-flash-exp",
+      "model": "gemini-2.5-flash",
       "supportsFunctionCalling": true
     }
   },
@@ -128,13 +128,15 @@ Notes:
   - Options: `-o, --output <file>`, `-v, --verbose`
 - `play <url>` – Send a media URL directly to an FF1 device
   - Options: `-d, --device <name>`, `--skip-verify`
-- `validate <file>` / `verify <file>` – Validate a DP1 playlist file
+- `validate <file-or-url>` / `verify <file-or-url>` – Validate a DP1 playlist file
 - `sign <file>` – Sign playlist with Ed25519
   - Options: `-k, --key <base64>`, `-o, --output <file>`
-- `send <file>` – Send playlist to an FF1 device
+- `send <file>` – Send a local or hosted DP-1 playlist to an FF1 device
   - Options: `-d, --device <name>`, `--skip-verify`
 - `publish <file>` – Publish a playlist to a feed server
   - Options: `-s, --server <index>` (server index if multiple configured)
+- `ssh <enable|disable>` – Manage SSH access on an FF1 device
+  - Options: `-d, --device <name>`, `--pubkey <path>`, `--ttl <duration>`
 - `config <init|show|validate>` – Manage configuration
 
 ## Usage Highlights
@@ -163,7 +165,7 @@ How it works (at a glance):
 - If `deviceName` is present, the CLI will send the validated playlist to that FF1 device.
 - If `feedServer` is present (via "publish to my feed"), the CLI will publish the playlist to the selected feed server.
 
-Use `--model grok|chatgpt|gemini` to switch models, or set `defaultModel` in `config.json`.
+Use `--model grok|gpt|gemini` to switch models, or set `defaultModel` in `config.json`.
 
 ### Natural language publishing
 
@@ -205,10 +207,28 @@ npm run dev -- sign playlist.json -o signed.json
 # Send to device (verifies by default)
 npm run dev -- send playlist.json -d "Living Room Display"
 
+# The send path now performs a compatibility preflight check against the target FF1.
+# If the device reports an unsupported FF1 OS version, the command fails with
+# a clear version message before any cast request is sent.
+# Send a hosted DP-1 playlist
+npm run dev -- send "https://cdn.example.com/playlist.json" -d "Living Room Display"
+
 # Play a direct URL
 npm run dev -- play "https://example.com/video.mp4" -d "Living Room Display" --skip-verify
 ```
 
+### SSH access
+
+```bash
+# Enable SSH access for 30 minutes
+ff1 ssh enable --pubkey ~/.ssh/id_ed25519.pub --ttl 30m -d "Living Room Display"
+
+# Disable SSH access
+ff1 ssh disable -d "Living Room Display"
+
+# `ff1 ssh` also performs the same FF1 OS compatibility preflight used by `send`.
+```
+
 ### Publish to feed server
 
 ```bash

package/docs/RELEASING.md

@@ -27,7 +27,12 @@ Run the appropriate script on each target platform and upload each pair to the G
 ## GitHub Actions
 
 - **Build** (`build.yml`): Trigger manually (Actions → Build → Run workflow) or on pull requests. Builds binaries on macOS, Linux, and Windows and uploads them as workflow artifacts for download.
-- **Release** (`release.yml`): Triggered when you **publish a release** (create a release from the repo Releases page, or publish an existing draft). Builds the same binaries, then uploads them to that release. Pushing a tag alone does not run this; only creating/publishing a release does.
+- **Release** (`release.yml`): Triggered when you **publish a release** (create a release from the repo Releases page, or publish an existing draft). Validates that `package.json` matches the tag, publishes to npm, builds binaries, then uploads them to that release. Pushing a tag alone does not run this; only creating/publishing a release does.
+
+## npm Publish Requirements
+
+- Set `NPM_TOKEN` in GitHub Actions secrets with an npm automation token.
+- Ensure `package.json` version matches the release tag (e.g. tag `1.0.2` → `"version": "1.0.2"`). The release job fails fast when they differ.
 
 ## Installer Redirect
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ff1-cli",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "CLI to fetch NFT information and build DP1 playlists using Grok API",
   "main": "dist/index.js",
   "bin": {
@@ -21,7 +21,7 @@
     "start": "node dist/index.js",
     "dev": "tsx index.ts",
     "prepublishOnly": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "tsx tests/ff1-compatibility.test.ts",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write \"**/*.{js,ts}\"",
@@ -44,6 +44,7 @@
   "license": "MIT",
   "dependencies": {
     "axios": "^1.6.2",
+    "bonjour-service": "^1.3.0",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "dotenv": "^16.3.1",