ive-connect 0.1.0

package/dist/devices/buttplug/buttplug-device.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Buttplug Device Implementation
+ *
+ * Implements the HapticDevice interface for Buttplug devices
+ */
+import { DeviceCapability, DeviceInfo, HapticDevice, ScriptData } from "../../core/device-interface";
+import { EventEmitter } from "../../core/events";
+import { ButtplugSettings } from "./types";
+/**
+ * Buttplug device implementation
+ */
+export declare class ButtplugDevice extends EventEmitter implements HapticDevice {
+    private _api;
+    private _config;
+    private _connectionState;
+    private _isPlaying;
+    private _loadedScript;
+    private _currentScriptActions;
+    private _lastActionIndex;
+    private _playbackInterval;
+    private _playbackStartTime;
+    private _playbackRate;
+    private _loopPlayback;
+    readonly id: string;
+    readonly name: string;
+    readonly type: string;
+    readonly capabilities: DeviceCapability[];
+    constructor(config?: Partial<ButtplugSettings>);
+    /**
+     * Get connected state
+     */
+    get isConnected(): boolean;
+    /**
+     * Get playing state
+     */
+    get isPlaying(): boolean;
+    /**
+     * Connect to Buttplug server
+     */
+    connect(config?: Partial<ButtplugSettings>): Promise<boolean>;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): Promise<boolean>;
+    /**
+     * Get current configuration
+     */
+    getConfig(): ButtplugSettings;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<ButtplugSettings>): Promise<boolean>;
+    /**
+     * Load a script for playback
+     */
+    loadScript(scriptData: ScriptData): Promise<boolean>;
+    /**
+     * Play the loaded script
+     */
+    play(timeMs: number, playbackRate?: number, loop?: boolean): Promise<boolean>;
+    /**
+     * Stop playback
+     */
+    stop(): Promise<boolean>;
+    /**
+     * Sync playback time
+     */
+    syncTime(timeMs: number): Promise<boolean>;
+    /**
+     * Get device information
+     */
+    getDeviceInfo(): DeviceInfo | null;
+    /**
+     * Process script actions based on current time
+     */
+    private _processActions;
+    /**
+     * Find the action index for the given time
+     */
+    private _findActionIndexForTime;
+    /**
+     * Set up event handlers for the Buttplug API
+     */
+    private _setupApiEventHandlers;
+}

package/dist/devices/buttplug/buttplug-device.js

@@ -0,0 +1,511 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ButtplugDevice = void 0;
+/**
+ * Buttplug Device Implementation
+ *
+ * Implements the HapticDevice interface for Buttplug devices
+ */
+const device_interface_1 = require("../../core/device-interface");
+const events_1 = require("../../core/events");
+const buttplug_api_1 = require("./buttplug-api");
+const types_1 = require("./types");
+const buttplug_server_1 = require("./buttplug-server");
+const command_helpers_1 = require("./command-helpers");
+/**
+ * Default Buttplug configuration
+ */
+const DEFAULT_CONFIG = {
+    id: "buttplug",
+    name: "Buttplug Devices",
+    enabled: true,
+    connectionType: types_1.ButtplugConnectionType.LOCAL,
+    clientName: (0, buttplug_server_1.generateClientName)(),
+    allowedFeatures: {
+        vibrate: true,
+        rotate: true,
+        linear: true,
+    },
+    devicePreferences: {},
+};
+/**
+ * Buttplug device implementation
+ */
+class ButtplugDevice extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this._connectionState = device_interface_1.ConnectionState.DISCONNECTED;
+        this._isPlaying = false;
+        this._loadedScript = null;
+        this._currentScriptActions = [];
+        this._lastActionIndex = -1;
+        this._playbackInterval = null;
+        this._playbackStartTime = 0;
+        this._playbackRate = 1.0;
+        this._loopPlayback = false;
+        this.id = "buttplug";
+        this.name = "Buttplug Devices";
+        this.type = "buttplug";
+        this.capabilities = [
+            device_interface_1.DeviceCapability.VIBRATE,
+            device_interface_1.DeviceCapability.ROTATE,
+            device_interface_1.DeviceCapability.LINEAR,
+        ];
+        this._config = { ...DEFAULT_CONFIG };
+        if (config) {
+            Object.assign(this._config, config);
+        }
+        this._api = new buttplug_api_1.ButtplugApi(this._config.clientName);
+        this._setupApiEventHandlers();
+    }
+    /**
+     * Get connected state
+     */
+    get isConnected() {
+        return this._connectionState === device_interface_1.ConnectionState.CONNECTED;
+    }
+    /**
+     * Get playing state
+     */
+    get isPlaying() {
+        return this._isPlaying;
+    }
+    /**
+     * Connect to Buttplug server
+     */
+    async connect(config) {
+        try {
+            // Update config if provided
+            if (config) {
+                await this.updateConfig(config);
+            }
+            // Check if WebBluetooth is supported for local connections
+            if (this._config.connectionType === types_1.ButtplugConnectionType.LOCAL &&
+                !(0, buttplug_server_1.isWebBluetoothSupported)()) {
+                this.emit("error", "WebBluetooth is not supported in this browser or device");
+                return false;
+            }
+            // Update connection state
+            this._connectionState = device_interface_1.ConnectionState.CONNECTING;
+            this.emit("connectionStateChanged", this._connectionState);
+            // Connect to the server
+            const success = await this._api.connect(this._config.connectionType, this._config.serverUrl);
+            if (success) {
+                this._connectionState = device_interface_1.ConnectionState.CONNECTED;
+                this.emit("connectionStateChanged", this._connectionState);
+                this.emit("connected", this.getDeviceInfo());
+                // Start scanning for devices automatically
+                this._api.startScanning().catch((error) => {
+                    console.error("Error starting device scan:", error);
+                });
+                return true;
+            }
+            else {
+                this._connectionState = device_interface_1.ConnectionState.DISCONNECTED;
+                this.emit("connectionStateChanged", this._connectionState);
+                this.emit("error", "Failed to connect to Buttplug server");
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Buttplug: Error connecting to server:", error);
+            this._connectionState = device_interface_1.ConnectionState.DISCONNECTED;
+            this.emit("connectionStateChanged", this._connectionState);
+            this.emit("error", `Connection error: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    /**
+     * Disconnect from the server
+     */
+    async disconnect() {
+        try {
+            // Stop playback if active
+            if (this._isPlaying) {
+                await this.stop();
+            }
+            // Disconnect from server
+            await this._api.disconnect();
+            // Update state
+            this._connectionState = device_interface_1.ConnectionState.DISCONNECTED;
+            this.emit("connectionStateChanged", this._connectionState);
+            this.emit("disconnected");
+            return true;
+        }
+        catch (error) {
+            console.error("Buttplug: Error disconnecting:", error);
+            this._connectionState = device_interface_1.ConnectionState.DISCONNECTED;
+            this.emit("connectionStateChanged", this._connectionState);
+            this.emit("disconnected");
+            return true; // Return true anyway for better UX
+        }
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this._config };
+    }
+    /**
+     * Update configuration
+     */
+    async updateConfig(config) {
+        // Update local config
+        if (config.connectionType !== undefined) {
+            this._config.connectionType = config.connectionType;
+        }
+        if (config.serverUrl !== undefined) {
+            this._config.serverUrl = config.serverUrl;
+        }
+        if (config.clientName !== undefined) {
+            this._config.clientName = config.clientName;
+        }
+        if (config.allowedFeatures !== undefined) {
+            this._config.allowedFeatures = {
+                ...this._config.allowedFeatures,
+                ...config.allowedFeatures,
+            };
+        }
+        if (config.devicePreferences !== undefined) {
+            // Update device preferences in the API
+            for (const [index, prefs] of Object.entries(config.devicePreferences)) {
+                const deviceIndex = Number(index);
+                this._api.setDevicePreference(deviceIndex, prefs);
+            }
+            // Update local config
+            this._config.devicePreferences = {
+                ...this._config.devicePreferences,
+                ...config.devicePreferences,
+            };
+        }
+        // Update other fields if present
+        if (config.name !== undefined) {
+            this._config.name = config.name;
+        }
+        if (config.enabled !== undefined) {
+            this._config.enabled = config.enabled;
+        }
+        // Emit configuration changed event
+        this.emit("configChanged", this._config);
+        return true;
+    }
+    /**
+     * Load a script for playback
+     */
+    async loadScript(scriptData) {
+        var _a;
+        if (!this.isConnected) {
+            this.emit("error", "Cannot load script: Not connected to a server");
+            return false;
+        }
+        try {
+            // Parse script data
+            let scriptContent;
+            if (scriptData.content) {
+                // If content is directly provided
+                scriptContent = scriptData.content;
+            }
+            else if (scriptData.url) {
+                // If URL is provided, fetch the script
+                try {
+                    console.log(`[BUTTPLUG-SCRIPT] Fetching script from URL: ${scriptData.url}`);
+                    const response = await fetch(scriptData.url);
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch script: ${response.status} ${response.statusText}`);
+                    }
+                    scriptContent = await response.json();
+                    console.log(`[BUTTPLUG-SCRIPT] Script loaded successfully, actions:`, (_a = scriptContent.actions) === null || _a === void 0 ? void 0 : _a.length);
+                }
+                catch (error) {
+                    this.emit("error", `Failed to fetch script: ${error instanceof Error ? error.message : String(error)}`);
+                    return false;
+                }
+            }
+            else {
+                this.emit("error", "Invalid script data: Either URL or content must be provided");
+                return false;
+            }
+            // Validate script format (basic checks for funscript)
+            if (!scriptContent ||
+                !scriptContent.actions ||
+                !Array.isArray(scriptContent.actions)) {
+                this.emit("error", "Invalid script format: Missing actions array");
+                console.error("[BUTTPLUG-SCRIPT] Invalid script format:", scriptContent);
+                return false;
+            }
+            // Sort actions by timestamp
+            const actions = [...scriptContent.actions].sort((a, b) => a.at - b.at);
+            // Store the script and actions
+            this._loadedScript = scriptContent;
+            this._currentScriptActions = actions;
+            this._lastActionIndex = -1;
+            this.emit("scriptLoaded", {
+                type: scriptData.type || "funscript",
+                name: scriptContent.name || "Unnamed Script",
+                actions: this._currentScriptActions.length,
+            });
+            return true;
+        }
+        catch (error) {
+            console.error("Buttplug: Error loading script:", error);
+            this.emit("error", `Script loading error: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    /**
+     * Play the loaded script
+     */
+    async play(timeMs, playbackRate = 1.0, loop = false) {
+        if (!this.isConnected) {
+            this.emit("error", "Cannot play: Not connected to a server");
+            return false;
+        }
+        if (!this._loadedScript || !this._currentScriptActions.length) {
+            this.emit("error", "Cannot play: No script loaded");
+            return false;
+        }
+        try {
+            // Stop any existing playback
+            if (this._isPlaying) {
+                await this.stop();
+            }
+            // Set playback parameters
+            this._playbackStartTime = Date.now() - timeMs;
+            this._playbackRate = playbackRate;
+            this._loopPlayback = loop;
+            this._lastActionIndex = -1;
+            // Create command executor for all devices
+            const devices = this._api.getDevices();
+            const preferences = this._api.getDevicePreferences();
+            const executor = (0, command_helpers_1.createMultiDeviceCommandExecutor)(this._api, devices, preferences);
+            // Start playback
+            this._isPlaying = true;
+            // Create an interval to check for actions
+            this._playbackInterval = setInterval(() => {
+                this._processActions(executor);
+            }, 20); // Check every 20ms for smoother playback
+            this.emit("playbackStateChanged", {
+                isPlaying: this._isPlaying,
+                timeMs,
+                playbackRate,
+                loop,
+            });
+            return true;
+        }
+        catch (error) {
+            console.error("Buttplug: Error starting playback:", error);
+            this._isPlaying = false;
+            this.emit("error", `Playback error: ${error instanceof Error ? error.message : String(error)}`);
+            this.emit("playbackStateChanged", { isPlaying: false });
+            return false;
+        }
+    }
+    /**
+     * Stop playback
+     */
+    async stop() {
+        if (!this.isConnected) {
+            this.emit("error", "Cannot stop: Not connected to a server");
+            return false;
+        }
+        try {
+            // Clear playback interval
+            if (this._playbackInterval !== null) {
+                clearInterval(this._playbackInterval);
+                this._playbackInterval = null;
+            }
+            // Stop all devices
+            await this._api.stopAllDevices();
+            // Update playback state
+            this._isPlaying = false;
+            this._lastActionIndex = -1;
+            this.emit("playbackStateChanged", { isPlaying: false });
+            return true;
+        }
+        catch (error) {
+            console.error("Buttplug: Error stopping playback:", error);
+            this._isPlaying = false;
+            this.emit("error", `Stopping playback error: ${error instanceof Error ? error.message : String(error)}`);
+            this.emit("playbackStateChanged", { isPlaying: false });
+            return false;
+        }
+    }
+    /**
+     * Sync playback time
+     */
+    async syncTime(timeMs) {
+        if (!this.isConnected || !this._isPlaying) {
+            return false;
+        }
+        try {
+            // Update the playback start time based on the current time
+            this._playbackStartTime = Date.now() - timeMs;
+            return true;
+        }
+        catch (error) {
+            console.error("Buttplug: Error syncing time:", error);
+            return false;
+        }
+    }
+    /**
+     * Get device information
+     */
+    getDeviceInfo() {
+        // Get connected devices
+        const devices = this._api.getDevices();
+        if (devices.length === 0) {
+            return {
+                id: this.id,
+                name: this.name,
+                type: this.type,
+                deviceCount: 0,
+                devices: [],
+            };
+        }
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            deviceCount: devices.length,
+            devices: devices.map((device) => ({
+                index: device.index,
+                name: device.name,
+                features: [
+                    device.canVibrate ? "vibrate" : null,
+                    device.canRotate ? "rotate" : null,
+                    device.canLinear ? "linear" : null,
+                ].filter(Boolean),
+            })),
+        };
+    }
+    /**
+     * Process script actions based on current time
+     */
+    _processActions(executor) {
+        if (!this._isPlaying || !this._currentScriptActions.length) {
+            return;
+        }
+        // Calculate current time in the script
+        const currentTime = Date.now();
+        const elapsedMs = (currentTime - this._playbackStartTime) * this._playbackRate;
+        // Find the action for the current time
+        const actionIndex = this._findActionIndexForTime(elapsedMs);
+        // If we reached the end of the script
+        if (actionIndex === this._currentScriptActions.length - 1 &&
+            elapsedMs > this._currentScriptActions[actionIndex].at + 1000) {
+            if (this._loopPlayback) {
+                // Reset for loop playback
+                this._playbackStartTime = Date.now();
+                this._lastActionIndex = -1;
+                return;
+            }
+            else {
+                // We're past the end of the script, stop playback
+                this.stop().catch(console.error);
+                return;
+            }
+        }
+        // If we have a new action to execute
+        if (actionIndex !== this._lastActionIndex && actionIndex >= 0) {
+            const action = this._currentScriptActions[actionIndex];
+            const prevAction = actionIndex > 0
+                ? this._currentScriptActions[actionIndex - 1]
+                : { pos: 0 };
+            // Calculate duration for linear movement based on time to next action
+            let durationMs = 500; // Default duration if we can't determine
+            if (actionIndex < this._currentScriptActions.length - 1) {
+                const nextAction = this._currentScriptActions[actionIndex + 1];
+                durationMs = nextAction.at - action.at;
+                // Enforce a minimum duration to prevent erratic movement
+                durationMs = Math.max(100, durationMs);
+            }
+            // Execute the action on all devices
+            executor
+                .executeAction(action.pos, prevAction.pos, durationMs)
+                .catch((error) => {
+                console.error("Error executing action:", error);
+            });
+            this._lastActionIndex = actionIndex;
+        }
+    }
+    /**
+     * Find the action index for the given time
+     */
+    _findActionIndexForTime(timeMs) {
+        if (!this._currentScriptActions.length) {
+            return -1;
+        }
+        // If we're past the end of the script
+        if (timeMs >
+            this._currentScriptActions[this._currentScriptActions.length - 1].at) {
+            return this._currentScriptActions.length - 1;
+        }
+        // If we're before the beginning of the script
+        if (timeMs < this._currentScriptActions[0].at) {
+            return 0;
+        }
+        // Binary search for the action
+        let low = 0;
+        let high = this._currentScriptActions.length - 1;
+        let bestIndex = -1;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            if (this._currentScriptActions[mid].at <= timeMs) {
+                bestIndex = mid;
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        return bestIndex;
+    }
+    /**
+     * Set up event handlers for the Buttplug API
+     */
+    _setupApiEventHandlers() {
+        // Forward connection state changes
+        this._api.on("connectionStateChanged", (state) => {
+            let connectionState;
+            switch (state) {
+                case types_1.ButtplugConnectionState.CONNECTED:
+                    connectionState = device_interface_1.ConnectionState.CONNECTED;
+                    break;
+                case types_1.ButtplugConnectionState.CONNECTING:
+                    connectionState = device_interface_1.ConnectionState.CONNECTING;
+                    break;
+                default:
+                    connectionState = device_interface_1.ConnectionState.DISCONNECTED;
+                    break;
+            }
+            this._connectionState = connectionState;
+            this.emit("connectionStateChanged", connectionState);
+        });
+        // Forward device events
+        this._api.on("deviceAdded", (deviceInfo) => {
+            this.emit("deviceAdded", deviceInfo);
+        });
+        this._api.on("deviceRemoved", (deviceInfo) => {
+            this.emit("deviceRemoved", deviceInfo);
+        });
+        // Forward errors
+        this._api.on("error", (error) => {
+            this.emit("error", error);
+        });
+        // Forward scanning state changes
+        this._api.on("scanningChanged", (scanning) => {
+            this.emit("scanningChanged", scanning);
+        });
+        // Forward device preference changes
+        this._api.on("devicePreferenceChanged", (data) => {
+            this.emit("devicePreferenceChanged", data);
+            // Update local config
+            if (!this._config.devicePreferences) {
+                this._config.devicePreferences = {};
+            }
+            this._config.devicePreferences[data.deviceIndex] = data.preference;
+            this.emit("configChanged", this._config);
+        });
+    }
+}
+exports.ButtplugDevice = ButtplugDevice;

package/dist/devices/buttplug/buttplug-server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Buttplug Local Server
+ *
+ * Provides support for running a Buttplug server locally in the browser
+ */
+/**
+ * Check if WebBluetooth is supported in the current environment
+ */
+export declare function isWebBluetoothSupported(): boolean;
+/**
+ * Generate name for the client
+ */
+export declare function generateClientName(prefix?: string): string;

package/dist/devices/buttplug/buttplug-server.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Buttplug Local Server
+ *
+ * Provides support for running a Buttplug server locally in the browser
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWebBluetoothSupported = isWebBluetoothSupported;
+exports.generateClientName = generateClientName;
+// This module provides functionality to create a local WebBluetooth connector
+// The actual import of ButtplugWasmClientConnector is done dynamically in
+// the ButtplugApi class to ensure it only runs in browser environments
+/**
+ * Check if WebBluetooth is supported in the current environment
+ */
+function isWebBluetoothSupported() {
+    return (typeof window !== "undefined" &&
+        typeof window.navigator !== "undefined" &&
+        navigator.bluetooth !== undefined);
+}
+/**
+ * Generate name for the client
+ */
+function generateClientName(prefix = "IVE-Connect") {
+    // Add a random suffix to make the client name unique
+    return `${prefix}-${Math.floor(Math.random() * 10000)}`;
+}

package/dist/devices/buttplug/command-helpers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Command Helpers for Buttplug Devices
+ *
+ * Utility functions for converting script commands to Buttplug device commands
+ */
+import { ButtplugApi } from "./buttplug-api";
+import { ButtplugDeviceInfo, DevicePreference } from "./types";
+/**
+ * Convert script position (0-100) to device position (0.0-1.0)
+ */
+export declare function convertScriptPositionToDevicePosition(scriptPos: number, min?: number, max?: number, invert?: boolean): number;
+/**
+ * Create a command executor for a specific device
+ */
+export declare function createDeviceCommandExecutor(api: ButtplugApi, deviceInfo: ButtplugDeviceInfo, preferences: DevicePreference): {
+    executeAction: (pos: number, prevPos: number, durationMs: number) => Promise<void>;
+};
+/**
+ * Create a command executor for multiple devices
+ */
+export declare function createMultiDeviceCommandExecutor(api: ButtplugApi, devices: ButtplugDeviceInfo[], preferences: Map<number, DevicePreference>): {
+    executeAction: (pos: number, prevPos: number, durationMs: number) => Promise<void>;
+};