@feralfile/cli 1.1.1

package/dist/src/commands/helpers/ssh-helpers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTtlSeconds = parseTtlSeconds;
+exports.readPublicKeyFile = readPublicKeyFile;
+const fs_1 = require("fs");
+/**
+ * Parse a TTL duration string into seconds.
+ *
+ * Accepts a bare number ("900"), or a number with an `s`/`m`/`h` unit
+ * suffix ("15m", "2h"). Used by `ff1 ssh enable --ttl <ttl>`.
+ *
+ * @throws Error When the input does not match the supported format
+ */
+function parseTtlSeconds(ttl) {
+    const trimmed = ttl.trim();
+    const match = trimmed.match(/^(\d+)([smh]?)$/i);
+    if (!match) {
+        throw new Error('TTL must be a number of seconds or a duration like 15m or 2h');
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    if (Number.isNaN(value)) {
+        throw new Error('TTL value is not a number');
+    }
+    if (unit === 'm') {
+        return value * 60;
+    }
+    if (unit === 'h') {
+        return value * 60 * 60;
+    }
+    return value;
+}
+/**
+ * Read an SSH public key from a file. The contents are trimmed and
+ * required to be non-empty so callers can fail fast on truncated files.
+ */
+async function readPublicKeyFile(keyPath) {
+    const content = await fs_1.promises.readFile(keyPath, 'utf-8');
+    const trimmed = content.trim();
+    if (!trimmed) {
+        throw new Error('Public key file is empty');
+    }
+    return trimmed;
+}

package/dist/src/commands/play.js

@@ -0,0 +1,110 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../config");
+const playlist_source_1 = require("../utilities/playlist-source");
+const playlist_display_1 = require("./helpers/playlist-display");
+// ff1-device is still CommonJS; require keeps the interop simple.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { sendPlaylistToDevice } = require('../utilities/ff1-device');
+exports.playCommand = new commander_1.Command('play')
+    .description('Play a playlist or media URL on an FF1 device')
+    .argument('<source>', 'Playlist file, playlist URL, or media URL')
+    .option('-d, --device <name>', 'Device name (uses first device if not specified)')
+    .option('--skip-verify', 'Skip DP-1 structure validation (parse/schema) before playing; use only when you accept malformed envelopes')
+    .action(async (source, options) => {
+    try {
+        const config = (0, config_1.getConfig)();
+        const resolved = await (0, playlist_source_1.resolvePlaySource)(source, config.defaultDuration || 10);
+        const isPlaylistSource = resolved.kind === 'playlist';
+        const sourceLabel = isPlaylistSource
+            ? `${resolved.sourceType}: ${resolved.source}`
+            : resolved.source;
+        console.log(chalk_1.default.blue('\nPlay on FF1\n'));
+        if (!options.skipVerify) {
+            // Structure-only validation (same as `validate`, `verify`, send, and publish).
+            // Synthesized media-URL playlists are unsigned but parse as valid DP-1.
+            if (isPlaylistSource) {
+                console.log(chalk_1.default.cyan(`Validate playlist (${sourceLabel})`));
+            }
+            const verifier = await Promise.resolve().then(() => __importStar(require('../utilities/playlist-verifier')));
+            const { validatePlaylist } = verifier;
+            const validateResult = await validatePlaylist(resolved.playlist);
+            if (!validateResult.valid) {
+                (0, playlist_display_1.printPlaylistVerificationFailure)(validateResult, isPlaylistSource ? `source: ${sourceLabel}` : undefined);
+                process.exit(1);
+            }
+            if (isPlaylistSource) {
+                console.log(chalk_1.default.green('✓ Validated\n'));
+            }
+        }
+        const result = await sendPlaylistToDevice({
+            playlist: resolved.playlist,
+            deviceName: options.device,
+        });
+        if (result.success) {
+            console.log(chalk_1.default.green('✓ Playing'));
+            if (result.deviceName) {
+                console.log(chalk_1.default.dim(`  Device: ${result.deviceName}`));
+            }
+            if (result.device) {
+                console.log(chalk_1.default.dim(`  Host: ${result.device}`));
+            }
+            console.log();
+        }
+        else {
+            console.error(chalk_1.default.red('\nPlay failed:'), result.error);
+            if (result.details) {
+                console.error(chalk_1.default.dim(`  Details: ${result.details}`));
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if ((0, playlist_source_1.isPlaylistSourceUrl)(source)) {
+            (0, playlist_display_1.printPlaylistSourceLoadFailure)(source, error);
+        }
+        else {
+            console.error(chalk_1.default.red('\nError:'), error.message);
+        }
+        process.exit(1);
+    }
+});

package/dist/src/commands/publish.js

@@ -0,0 +1,115 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const prompt_1 = require("./helpers/prompt");
+exports.publishCommand = new commander_1.Command('publish')
+    .description('Publish a playlist to a feed server')
+    .argument('<file>', 'Path to the playlist file')
+    .option('-s, --server <index>', 'Feed server index (use this if multiple servers configured)')
+    .action(async (file, options) => {
+    try {
+        console.log(chalk_1.default.blue('\nPublish playlist\n'));
+        const { getFeedConfig } = await Promise.resolve().then(() => __importStar(require('../config')));
+        const { publishPlaylist } = await Promise.resolve().then(() => __importStar(require('../utilities/playlist-publisher')));
+        const feedConfig = getFeedConfig();
+        if (!feedConfig.baseURLs || feedConfig.baseURLs.length === 0) {
+            console.error(chalk_1.default.red('\nNo feed servers configured'));
+            console.log(chalk_1.default.yellow('  Add feed server URLs to config.json: feed.baseURLs\n'));
+            process.exit(1);
+        }
+        let serverUrl = feedConfig.baseURLs[0];
+        let serverApiKey = feedConfig.apiKey;
+        if (feedConfig.baseURLs.length > 1) {
+            if (!options.server) {
+                console.log(chalk_1.default.yellow('Multiple feed servers found. Select one:'));
+                console.log();
+                feedConfig.baseURLs.forEach((url, index) => {
+                    console.log(chalk_1.default.cyan(`  ${index}: ${url}`));
+                });
+                console.log();
+                const prompt = (0, prompt_1.createPrompt)();
+                const selection = await prompt.ask('Select server (0-based index): ');
+                prompt.close();
+                console.log();
+                options.server = selection;
+            }
+            const serverIndex = parseInt(options.server || '0', 10);
+            if (isNaN(serverIndex) || serverIndex < 0 || serverIndex >= feedConfig.baseURLs.length) {
+                console.error(chalk_1.default.red('\nInvalid server index'));
+                process.exit(1);
+            }
+            serverUrl = feedConfig.baseURLs[serverIndex];
+            if (feedConfig.servers && feedConfig.servers[serverIndex]) {
+                serverApiKey = feedConfig.servers[serverIndex].apiKey;
+            }
+        }
+        else if (feedConfig.servers && feedConfig.servers[0]) {
+            serverApiKey = feedConfig.servers[0].apiKey;
+        }
+        const result = await publishPlaylist(file, serverUrl, serverApiKey);
+        if (result.success) {
+            console.log(chalk_1.default.green('Published'));
+            if (result.playlistId) {
+                console.log(chalk_1.default.dim(`  Playlist ID: ${result.playlistId}`));
+            }
+            console.log(chalk_1.default.dim(`  Server: ${result.feedServer}`));
+            if (result.message) {
+                console.log(chalk_1.default.dim(`  Status: ${result.message}`));
+            }
+            console.log();
+        }
+        else {
+            console.error(chalk_1.default.red('\nPublish failed'));
+            if (result.error) {
+                console.error(chalk_1.default.red(`  ${result.error}`));
+            }
+            if (result.message) {
+                console.log(chalk_1.default.yellow(`\n${result.message}`));
+            }
+            console.log();
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError:'), error.message);
+        process.exit(1);
+    }
+});

package/dist/src/commands/setup.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = require("fs");
+const device_lookup_1 = require("../utilities/device-lookup");
+const device_upsert_1 = require("../utilities/device-upsert");
+const config_1 = require("../config");
+const config_files_1 = require("./helpers/config-files");
+const device_discovery_1 = require("./helpers/device-discovery");
+const prompt_1 = require("./helpers/prompt");
+const playlist_signing_role_1 = require("../utilities/playlist-signing-role");
+exports.setupCommand = new commander_1.Command('setup')
+    .description('Guided setup for config, signing key, and device')
+    .action(async () => {
+    let prompt = null;
+    try {
+        const { path: configPath, created } = await (0, config_files_1.ensureConfigFile)();
+        if (created) {
+            console.log(chalk_1.default.green(`Created ${configPath}`));
+        }
+        const config = await (0, config_files_1.readConfigFile)(configPath);
+        const mergedDefaults = (0, config_1.getConfig)();
+        // Show every known provider in the menu (in-code defaults first, then any
+        // custom providers the user has added to the file) so adding a new provider
+        // to defaults shows up for existing users without rerunning createSampleConfig.
+        const modelNames = Array.from(new Set([...(0, config_1.listAvailableModels)(), ...Object.keys(config.models || {})]));
+        if (modelNames.length === 0) {
+            console.error(chalk_1.default.red('No models found in config.json'));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.blue('\nFF1 Setup\n'));
+        prompt = (0, prompt_1.createPrompt)();
+        const ask = prompt.ask;
+        const currentModel = config.defaultModel && modelNames.includes(config.defaultModel)
+            ? config.defaultModel
+            : modelNames[0];
+        let selectedModel = currentModel;
+        while (true) {
+            const modelAnswer = await ask(`Default model (${modelNames.join(', ')}) [${currentModel}]: `);
+            if (!modelAnswer) {
+                selectedModel = currentModel;
+                break;
+            }
+            if (modelNames.includes(modelAnswer)) {
+                selectedModel = modelAnswer;
+                break;
+            }
+            console.log(chalk_1.default.red(`Unknown model: ${modelAnswer}`));
+        }
+        config.defaultModel = selectedModel;
+        if (!config.models) {
+            config.models = {};
+        }
+        // Seed missing entries from in-code defaults so baseURL/model are populated,
+        // but blank the apiKey so the user is prompted instead of silently inheriting
+        // an env-derived value.
+        const providerDefaults = mergedDefaults.models[selectedModel];
+        const selectedModelConfig = config.models[selectedModel] ||
+            (providerDefaults
+                ? { ...providerDefaults, apiKey: '' }
+                : {
+                    apiKey: '',
+                    baseURL: '',
+                    model: '',
+                    timeout: 0,
+                    maxRetries: 0,
+                    temperature: 0,
+                    maxTokens: 0,
+                    supportsFunctionCalling: true,
+                });
+        const hasApiKeyForModel = !(0, config_files_1.isMissingConfigValue)(selectedModelConfig.apiKey);
+        const keyHelpUrls = {
+            grok: 'https://console.x.ai/',
+            gpt: 'https://platform.openai.com/api-keys',
+            gemini: 'https://aistudio.google.com/app/apikey',
+            claude: 'https://console.anthropic.com/settings/keys',
+        };
+        if (!hasApiKeyForModel) {
+            const helpUrl = keyHelpUrls[selectedModel];
+            if (helpUrl) {
+                console.log(chalk_1.default.dim(helpUrl));
+            }
+        }
+        const apiKeyPrompt = hasApiKeyForModel
+            ? `API key for ${selectedModel} (leave blank to keep current): `
+            : `API key for ${selectedModel} (optional, only needed for chat): `;
+        const apiKeyAnswer = await ask(apiKeyPrompt);
+        if (apiKeyAnswer) {
+            selectedModelConfig.apiKey = apiKeyAnswer;
+        }
+        config.models[selectedModel] = selectedModelConfig;
+        const currentKey = config.playlist?.privateKey || '';
+        const currentRole = config.playlist?.role || '';
+        let signingKey = currentKey;
+        let signingRole = currentRole;
+        if ((0, config_files_1.isMissingConfigValue)(currentKey)) {
+            const keyPair = crypto_1.default.generateKeyPairSync('ed25519');
+            signingKey = keyPair.privateKey.export({ format: 'der', type: 'pkcs8' }).toString('base64');
+        }
+        else {
+            const keepKey = await (0, prompt_1.promptYesNo)(ask, 'Keep existing signing key?', true);
+            if (!keepKey) {
+                const keyAnswer = await ask('Paste signing key (base64 or hex), or leave blank to regenerate: ');
+                if (keyAnswer) {
+                    signingKey = keyAnswer;
+                }
+                else {
+                    const keyPair = crypto_1.default.generateKeyPairSync('ed25519');
+                    signingKey = keyPair.privateKey
+                        .export({ format: 'der', type: 'pkcs8' })
+                        .toString('base64');
+                }
+            }
+        }
+        if (signingKey) {
+            const roleHint = playlist_signing_role_1.DP1_PLAYLIST_SIGNING_ROLES.join(', ');
+            while (true) {
+                const roleAnswer = await ask(`Signing role (${roleHint}) [${currentRole || 'agent'}]: `);
+                try {
+                    signingRole = (0, playlist_signing_role_1.resolveDp1PlaylistSigningRole)(roleAnswer, signingRole || 'agent');
+                    break;
+                }
+                catch (error) {
+                    console.log(chalk_1.default.red(error.message));
+                    if (!roleAnswer.trim()) {
+                        console.log(chalk_1.default.dim('Enter one of the supported roles above, or fix the stored value.'));
+                    }
+                }
+            }
+            config.playlist = {
+                ...(config.playlist || {}),
+                privateKey: signingKey,
+                role: signingRole,
+            };
+        }
+        const existingDevices = config.ff1Devices?.devices || [];
+        if (existingDevices.length > 0) {
+            console.log(chalk_1.default.dim(`\nConfigured devices: ${existingDevices.map((d) => d.name || d.host).join(', ')}`));
+        }
+        const selection = await (0, device_discovery_1.discoverAndSelectDevice)(ask, existingDevices, { allowSkip: true });
+        if (selection.hostValue) {
+            // Prefer the already-stored label so re-running setup (or re-adding a device
+            // that returned on a new IP) doesn't clobber the friendly name.
+            const existingEntry = (0, device_lookup_1.findExistingDeviceEntry)(existingDevices, selection.hostValue, selection.discoveredName, selection.discoveredId, selection.discoveredAddresses);
+            const existingIndex = existingEntry
+                ? existingDevices.findIndex((d) => d === existingEntry)
+                : -1;
+            const existingName = existingEntry?.name || '';
+            const defaultName = existingName || selection.discoveredName || 'art-computer';
+            const namePrompt = defaultName !== 'art-computer'
+                ? `Device name (kitchen, office, etc.) [${defaultName}]: `
+                : 'Device name (kitchen, office, etc.): ';
+            const nameAnswer = await ask(namePrompt);
+            let deviceName = nameAnswer || defaultName || 'art-computer';
+            // Same name-collision guard as `device add`: reject names that would
+            // clobber a different device entry. Only fires when existingIndex !== -1
+            // (we know the row); when existingIndex === -1, a same-name entry is the
+            // case-3 migration path.
+            const setupNameConflict = existingIndex !== -1
+                ? existingDevices.find((d, i) => d.name === deviceName && i !== existingIndex)
+                : undefined;
+            if (setupNameConflict) {
+                console.log(chalk_1.default.yellow(`"${deviceName}" is already used by another device. Please choose a different name.`));
+                const retryAnswer = await ask('Device name: ');
+                deviceName = retryAnswer || 'art-computer';
+                const retryConflict = existingIndex !== -1
+                    ? existingDevices.find((d, i) => d.name === deviceName && i !== existingIndex)
+                    : undefined;
+                if (retryConflict) {
+                    console.log(chalk_1.default.yellow(`"${deviceName}" is also taken. Skipping device.`));
+                    config.ff1Devices = { devices: existingDevices };
+                    await fs_1.promises.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+                    return;
+                }
+            }
+            const result = (0, device_upsert_1.upsertDevice)(existingDevices, {
+                name: deviceName,
+                host: selection.hostValue,
+                id: selection.discoveredId,
+                addresses: selection.discoveredAddresses,
+            }, existingIndex !== -1 ? existingIndex : undefined);
+            console.log(chalk_1.default.dim(`${result.updated ? 'Updated' : 'Added'} device: ${deviceName}`));
+            config.ff1Devices = { devices: result.devices };
+        }
+        else if (existingDevices.length > 0) {
+            config.ff1Devices = { devices: existingDevices };
+        }
+        await fs_1.promises.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+        prompt.close();
+        prompt = null;
+        console.log(chalk_1.default.green('\nSetup complete'));
+        console.log(chalk_1.default.dim(`   Config: ${configPath}`));
+        const hasApiKey = !(0, config_files_1.isMissingConfigValue)(config.models[selectedModel]?.apiKey);
+        const hasSigningKey = !(0, config_files_1.isMissingConfigValue)(config.playlist?.privateKey || '');
+        const hasDevice = Boolean(config.ff1Devices?.devices?.[0]?.host);
+        if (!hasSigningKey || !hasDevice) {
+            console.log(chalk_1.default.yellow('\nNext steps:'));
+            if (!hasSigningKey) {
+                console.log(chalk_1.default.yellow('  • Add a playlist signing key'));
+            }
+            if (!hasDevice) {
+                console.log(chalk_1.default.yellow('  • Add an FF1 device host'));
+            }
+        }
+        if (!hasApiKey) {
+            console.log(chalk_1.default.dim(`\nTo use ff-cli chat, add an API key for ${selectedModel}`));
+        }
+        console.log(chalk_1.default.dim('\nRun: ff-cli play'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nSetup failed:'), error.message);
+        process.exit(1);
+    }
+    finally {
+        if (prompt) {
+            prompt.close();
+        }
+    }
+});

package/dist/src/commands/sign.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+// playlist-signer is still CommonJS; require keeps the interop simple.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { signPlaylistFile } = require('../utilities/playlist-signer');
+exports.signCommand = new commander_1.Command('sign')
+    .description('Sign a DP1 playlist file with a DP-1 signature envelope')
+    .argument('<file>', 'Path to the playlist file to sign')
+    .option('-k, --key <privateKey>', 'Ed25519 private key in base64 format (overrides config)')
+    .option('-r, --role <role>', 'DP-1 signing role (overrides config)')
+    .option('-o, --output <file>', 'Output file path (defaults to overwriting input file)')
+    .action(async (file, options) => {
+    try {
+        console.log(chalk_1.default.blue('\nSign playlist\n'));
+        const result = await signPlaylistFile(file, options.key, options.output, options.role);
+        if (result.success) {
+            console.log(chalk_1.default.green('\nPlaylist signed'));
+            if (Array.isArray(result.playlist?.signatures)) {
+                console.log(chalk_1.default.dim(`  Signatures: ${result.playlist.signatures.length}`));
+            }
+            else if (result.playlist?.signature) {
+                console.log(chalk_1.default.dim(`  Signature: ${result.playlist.signature.substring(0, 30)}...`));
+            }
+            console.log();
+        }
+        else {
+            console.error(chalk_1.default.red('\nSign failed:'), result.error);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError:'), error.message);
+        process.exit(1);
+    }
+});

package/dist/src/commands/ssh.js

@@ -0,0 +1,108 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sshCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ssh_helpers_1 = require("./helpers/ssh-helpers");
+// `ssh` is a single command with an action argument rather than a
+// commander subcommand group. Kept this way to preserve the existing
+// CLI surface (`ff1 ssh enable|disable`) used in scripts.
+exports.sshCommand = new commander_1.Command('ssh')
+    .description('Enable or disable SSH access on an FF1 device')
+    .argument('<action>', 'Action: enable or disable')
+    .option('-d, --device <name>', 'Device name (uses first device if not specified)')
+    .option('--pubkey <path>', 'SSH public key file (required for enable)')
+    .option('--ttl <duration>', 'Auto-disable after duration (e.g. 30m, 2h, 900s)')
+    .action(async (action, options) => {
+    try {
+        const normalizedAction = action.trim().toLowerCase();
+        if (normalizedAction !== 'enable' && normalizedAction !== 'disable') {
+            console.error(chalk_1.default.red('\nUnknown action:'), action);
+            console.log(chalk_1.default.yellow('Available actions: enable, disable\n'));
+            process.exit(1);
+        }
+        const isEnable = normalizedAction === 'enable';
+        let publicKey;
+        if (isEnable) {
+            if (!options.pubkey) {
+                console.error(chalk_1.default.red('\nPublic key is required to enable SSH'));
+                console.log(chalk_1.default.yellow('Use: ff1 ssh enable --pubkey ~/.ssh/id_ed25519.pub\n'));
+                process.exit(1);
+            }
+            publicKey = await (0, ssh_helpers_1.readPublicKeyFile)(options.pubkey);
+        }
+        let ttlSeconds;
+        if (options.ttl) {
+            ttlSeconds = (0, ssh_helpers_1.parseTtlSeconds)(options.ttl);
+        }
+        const { sendSshAccessCommand } = await Promise.resolve().then(() => __importStar(require('../utilities/ssh-access')));
+        const result = await sendSshAccessCommand({
+            enabled: isEnable,
+            deviceName: options.device,
+            publicKey,
+            ttlSeconds,
+        });
+        if (result.success) {
+            console.log(chalk_1.default.green(`SSH ${isEnable ? 'enabled' : 'disabled'}`));
+            if (result.deviceName) {
+                console.log(chalk_1.default.dim(`  Device: ${result.deviceName}`));
+            }
+            if (result.device) {
+                console.log(chalk_1.default.dim(`  Host: ${result.device}`));
+            }
+            if (result.response && typeof result.response === 'object') {
+                const expiresAt = result.response.expiresAt;
+                if (expiresAt) {
+                    console.log(chalk_1.default.dim(`  Expires: ${expiresAt}`));
+                }
+            }
+            console.log();
+            return;
+        }
+        console.error(chalk_1.default.red('\nSSH request failed:'), result.error);
+        if (result.details) {
+            console.error(chalk_1.default.dim(`  Details: ${result.details}`));
+        }
+        process.exit(1);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError:'), error.message);
+        process.exit(1);
+    }
+});