Scrypted Scripts

https://scripts.scrypted.app/
Admin
Scrypted Scripts provides a collection of lightweight, user-editable scripts for adding powerful...
Tokens:13,488
Snippets:71
Trust Score:8.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Chromecast Camera Button Script

Source: https://scripts.scrypted.app/camera-chromecast-button.html

This TypeScript script defines a Scrypted device that acts as a switch to stream a camera feed to one or more Chromecast devices. It handles starting and stopping the stream, with a configurable duration. Ensure the Chromecast and Scrypted Cloud plugins are installed.

```typescript
const DEFAULT_TIMEOUT_SECS = 60;

class ChromecastCameraButton extends ScryptedDeviceBase implements OnOff, Settings {
    timeout: any;

    constructor(nativeId: string) {
        super(nativeId);
        // make this device a switch so it can be synced.
        setTimeout(() => {
            systemManager.getDeviceById(this.id).setType(ScryptedDeviceType.Switch);
        });
    }

    async turnOn() {
        const ids = this.getJSON('chromecasts') as string[];
        const camera = systemManager.getDeviceById<RTCSignalingChannel>(this.getJSON('camera') as string);
        clearTimeout(this.timeout);

        const promises = ids.map(async id => {
            const chromecast = systemManager.getDeviceById<RTCSignalingClient & StartStop>(id);
            try {
                if (!chromecast) {
                    throw new Error(`Device is missing: ${id}`);
                } else {
                    await camera.startRTCSignalingSession(await chromecast.createRTCSignalingSession());
                    return;
                }
            } catch (error) {
                console.warn('Failed to start', id, chromecast?.name, error);
            }
        });

        await Promise.allSettled(promises);

        const duration = parseFloat(this.getJSON('duration') as string) || DEFAULT_TIMEOUT_SECS;
        this.timeout = setTimeout(() => this.turnOff(), duration * 1000);
        this.on = true;
    }

    async turnOff() {
        const ids = this.getJSON('chromecasts') as string[];
        const promises = ids.map(async id => {
            const chromecast = systemManager.getDeviceById<RTCSignalingClient & StartStop>(id);
            try {
                if (!chromecast) {
                    throw new Error(`Device is missing: ${id}`);
                } else {
                    await chromecast.stop();
                    return;
                }
            } catch (error) {
                console.warn('Failed to stop', id, chromecast?.name, error);
            }
        });

        await Promise.allSettled(promises);
        this.on = false;
    }

    async getSettings(): Promise<Setting[]> {
        return [
            {
                title: 'Camera',
                key: 'camera',
                value: this.getJSON('camera'),
                type: 'device',
                deviceFilter: `interfaces.includes("${ScryptedInterface.RTCSignalingChannel}")`,
            },
            {
                title: 'Chromecasts',
                key: 'chromecasts',
                value: this.getJSON('chromecasts'),
                type: 'device',
                deviceFilter: `interfaces.includes("${ScryptedInterface.RTCSignalingClient}")`,
                multiple: true,
            },
            {
                title: 'Duration',
                key: 'duration',
                value: this.getJSON('duration') || this.DEFAULT_TIMEOUT_SECS,
                type: 'number',
                description: 'Duration in seconds to stream the camera on the Chromecast.',
            }
        ]
    }

    async putSetting(key: string, value: SettingValue) {
        this.storage.setItem(key, JSON.stringify(value));
        deviceManager.onDeviceEvent(this.nativeId, ScryptedInterface.Settings, undefined);
    }

    getJSON(key: string): SettingValue {
        try {
            return JSON.parse(this.storage.getItem(key));
        } catch (e) {
            return [];
        }
    }
}

export default ChromecastCameraButton;

```

--------------------------------

### RATGDO MQTT Script

Source: https://scripts.scrypted.app/ratgdo-mqtt.html

This TypeScript script integrates a RATGDO device with Scrypted using MQTT. It subscribes to status updates and exposes controls for the garage door and light. Ensure the MQTT settings match the RATGDO's configuration.

```typescript
let obstructed = false;
let door: string;

function updateStatus() {
    if (obstructed) {
        device.entryOpen = 'jammed';
    }
    else {
        device.entryOpen = door !== 'closed';
    }
}

mqtt.subscribe({
    'status/light': value => {
        device.on = value.text !== 'off';
    },
    'status/door': value => {
        door = value.text;
        updateStatus();
    },
    'status/obstruction': value => {
        obstructed = value.text !== 'clear';
        updateStatus();
    }
});

export default {
    turnOff: () => mqtt.publish('command/light', 'off', {
        retain: false,
    }),
    turnOn: () => mqtt.publish('command/light', 'on', {
        retain: false,
    }),
    openEntry: () => mqtt.publish('command/door', 'open'),
    closeEntry: () => mqtt.publish('command/door', 'close'),
} as OnOff & Entry & EntrySensor;

mqtt.handleTypes(ScryptedInterface.EntrySensor);

systemManager.getDeviceById(device.id).setType(ScryptedDeviceType.Garage);
```

--------------------------------

### Minimal Switch Implementation

Source: https://scripts.scrypted.app/minimal-switch.html

This TypeScript code defines a Scrypted device that acts as a switch. It initializes the device type and logs its state changes to the console. Ensure the device is properly registered within the Scrypted system.

```typescript
export default class ConsoleDemo extends ScryptedDeviceBase implements OnOff {
    constructor(nativeId: ScryptedNativeId) {
        super(nativeId);
        // make this device a switch so it can be synced.
        setTimeout(() => {
            systemManager.getDeviceById(this.id).setType(ScryptedDeviceType.Switch);
            if (device.on === undefined) {
                device.on = false;
            }
        }, 1000);
    }
    
    async turnOff(): Promise<void> {
        this.on = false;
        this.console.info("The switch is Off");
    }
    async turnOn(): Promise<void> {
        this.on = true;
        this.console.info("The switch is On");
    }    
}
```

--------------------------------

### PTZ Button Script

Source: https://scripts.scrypted.app/ptz-preset-button.html

This TypeScript script defines a PTZButton class that extends ScryptedDeviceBase. It implements OnOff and Settings interfaces to create a switch-like device that moves a PTZ camera to a configured preset position when activated. The preset can be selected from a list of available presets for the linked PTZ camera.

```typescript
class PTZButton extends ScryptedDeviceBase implements OnOff, Settings {
    timeout: any;
    storageSettings = new StorageSettings(this, {
        ptzCamera: {
            immediate: true,
            title: 'PTZ Camera',
            type: 'device',
            deviceFilter: `interfaces.includes("${ScryptedInterface.PanTiltZoom}")`,
        },
        preset: {
            title: 'Preset',
        },
    })

    constructor(nativeId: string) {
        super(nativeId);
        // make this device a switch so it can be synced.
        setTimeout(() => {
            systemManager.getDeviceById(this.id).setType(ScryptedDeviceType.Switch);
        });

        this.storageSettings.settings.preset.onGet = async () => {
            const ptzCamera: ScryptedDevice & PanTiltZoom = this.storageSettings.values.ptzCamera;
            const choices = Object.values(ptzCamera?.ptzCapabilities?.presets || {});
            return {
                choices,
            }
        };
    }

    async turnOn() {
        this.on = true;
        clearTimeout(this.timeout);
        // reset the switch after a second so you can press it again!
        this.timeout = setTimeout(() => this.on = false, 1000);

        const ptzCamera: ScryptedDevice & PanTiltZoom = this.storageSettings.values.ptzCamera;
        const found = Object.entries(ptzCamera.ptzCapabilities?.presets || {}).find(([k, v]) => v === this.storageSettings.values.preset);

        await ptzCamera.ptzCommand({
            movement: PanTiltZoomMovement.Preset,
            preset: found[0],
        });
    }

    async turnOff() {
        this.on = false;
    }

    async getSettings(): Promise<Setting[]> {
        return this.storageSettings.getSettings();
    }

    async putSetting(key: string, value: SettingValue) {
        return this.storageSettings.putSetting(key, value);
    }
}

export default PTZButton;

```

--------------------------------

### Camera Temperature Overlay Script

Source: https://scripts.scrypted.app/temperature-overlay.html

The main TypeScript class for the Camera Temperature Overlay script. It implements ScryptedDeviceBase and Settings, managing configuration and temperature updates.

```typescript
export default class CameraTemperatureOverlay extends ScryptedDeviceBase implements Settings {
    storageSettings = new StorageSettings(this, {
        temperatureUnit: {
            title: 'Temperature Unit',
            choices: ['C', 'F'],
            defaultValue: 'C',
            onPut: () => this.refreshTemperature(),
        },
        linkedPositionSensor: {
            title: 'Linked PositionSensor',
            description: 'A PositionSensor to provide geolocation data.',
            value: this.storage.getItem('linkedPositionSensor'),
            deviceFilter: `interfaces.includes('${ScryptedInterface.PositionSensor}')`,
            type: 'device',
            onPut: () => {
                this.forecastUrl = undefined;
                this.refreshTemperature();
                this.positionListener?.removeListener();
                this.positionListener = undefined;
                if (this.storageSettings.values.linkedPositionSensor) {
                    const positionSensor = this.storageSettings.values.linkedPositionSensor as ScryptedDevice & PositionSensor;
                    this.positionListener = positionSensor.listen(ScryptedInterface.PositionSensor, () => {
                        this.forecastUrl = undefined;
                        this.refreshTemperature();
                    });
                }
            },
        },
        latitude: {
            type: 'number',
            title: 'Latitude',
            description: 'Takes precedence over the linked PositionSensor.',
            onPut: () => {
                this.forecastUrl = undefined;
                this.refreshTemperature();
            },
        },
        longitude: {
            type: 'number',
            title: 'Longitude',
            description: 'Takes precedence over the linked PositionSensor.',
            onPut: () => {
                this.forecastUrl = undefined;
                this.refreshTemperature();
            },
        },
        cameras: {
            title: 'Cameras',
            type: 'device',
            deviceFilter: d => {
                return d.interfaces.includes(ScryptedInterface.VideoTextOverlays);
            },
            multiple: true,
            onPut: () => this.refreshTemperature(),
        },
        overlayIds: {
            title: 'Overlay IDs',
            description: 'The overlay ids to display the temperature. The camera overlays will be searched in order for a match. If there is no match, available overlay ids will be printed to the Log.',
            multiple: true,
            choices: [],
            combobox: true,
            defaultValue: [],
            onPut: () => this.refreshTemperature(),
        },
    });
    forecastUrl: Promise<string>;
    overlayIds = new Map<string, Promise<string>>();
    positionListener: EventListenerRegister;

    constructor(nativeId: ScryptedNativeId) {
        super(nativeId);

        this.refreshTemperature();
        setInterval(() => this.refreshTemperature(), 5 * 60 * 1000);
    }

    async getSettings() {
        return this.storageSettings.getSettings();
    }

    async putSetting(key: string, value: SettingValue) {
        return this.storageSettings.putSetting(key, value);
    }

    async refreshTemperature() {
        if (
            (
                !this.storageSettings.values.linkedPositionSensor && (!this.storageSettings.values.latitude || !this.storageSettings.values.longitude)
            )
            || !this.storageSettings.values.cameras.length
        ) {
            this.console.warn('Camera temperature overlay is not configured');
            return;
        }

        const cameras = (this.storageSettings.values.cameras as string[])
            .map(id => systemManager.getDeviceById<VideoTextOverlays>(id));

        if (!cameras.length) {
            this.console.warn('Camera temperature overlay is not configured with valid cameras');
            return;
        }

        if (!this.forecastUrl) {
            this.forecastUrl = (async () => {
                const positionSensor = this.storageSettings.values.linkedPositionSensor as ScryptedDevice & PositionSensor;
                const latitude = this.storageSettings.values.latitude || positionSensor.position.latitude;
                const longitude = this.storageSettings.values.longitude || positionSensor.position.longitude;

```

--------------------------------

### PTZ Button Implementation

Source: https://scripts.scrypted.app/ptz-button.html

This TypeScript code defines a Scrypted device that acts as a switch. When turned on, it triggers a PTZ command on a configured camera. The switch resets automatically after a short delay. Settings allow configuration of the target PTZ camera, the command to execute, and the movement distance.

```typescript
class PTZButton extends ScryptedDeviceBase implements OnOff, Settings {
    timeout: any;

    constructor(nativeId: string) {
        super(nativeId);
        // make this device a switch so it can be synced.
        setTimeout(() => {
            systemManager.getDeviceById(this.id).setType(ScryptedDeviceType.Switch);
        });
    }

    async turnOn() {
        this.on = true;
        clearTimeout(this.timeout);
        // reset the switch after a second so you can press it again!
        this.timeout = setTimeout(() => this.on = false, 1000);

        const ptzCamera = systemManager.getDeviceById<PanTiltZoom>(this.storage.getItem('ptzCamera'));

        // when the button is pressed, spin 90 degrees.
        // range is between -1 (-180 degrees) and 1 (180 degrees)
        await ptzCamera.ptzCommand({
            [this.storage.getItem('command') || 'pan']: parseFloat(this.storage.getItem('distance')) || .5,
        });
    }

    async turnOff() {
        this.on = false;
    }

    async getSettings(): Promise<Setting[]> {
        return [
            {
                title: 'PTZ Camera',
                key: 'ptzCamera',
                value: this.storage.getItem('ptzCamera'),
                type: 'device',
                deviceFilter: `interfaces.includes("${ScryptedInterface.PanTiltZoom}")`,
            },
            {
                title: 'Command',
                key: 'command',
                value: this.storage.getItem('command') || 'pan',
                choices:
                    [
                        'pan',
                        'tilt',
                        'zoom',
                    ],
            },
            {
                title: 'Distance',
                description: 'The distance to move. Between 0 and 1.',
                key: 'distance',
                type: 'number',
                value: this.storage.getItem('distance') || .5,
            }
        ]
    }

    async putSetting(key: string, value: SettingValue) {
        this.storage.setItem(key, value?.toString());
        deviceManager.onDeviceEvent(this.nativeId, ScryptedInterface.Settings, undefined);
    }
}

export default PTZButton;

```

--------------------------------

### Object Detection Benchmark Script

Source: https://scripts.scrypted.app/object-detection-benchmark.html

This script benchmarks object detection plugins by simulating camera feeds and running detections in batches. It logs progress, CPU/Memory info, and calculates the detection rate.

```typescript
const os = require('os');
const { execSync } = require('child_process');

const mo = await mediaManager.createMediaObjectFromUrl('https://user-images.githubusercontent.com/73924/230690188-7a25983a-0630-44e9-9e2d-b4ac150f1524.jpg');
const image = await mediaManager.convertMediaObject<Image & MediaObject>(mo, 'x-scrypted/x-scrypted-image');
const detectors = [
    '@scrypted/openvino',
    '@scrypted/ncnn',
    '@scrypted/coreml',
    '@scrypted/onnx',
    '@scrypted/tensorflow-lite',
    '@scrypted/rknn',
];
const simulatedCameras = 4;
const batch = 4;
const batchesPerCamera = 125;

function logProgress(current: number, total: number, startTime: number) {
    const percentage = Math.floor((current / total) * 100);
    const elapsedTime = (Date.now() - startTime) / 1000;
    const estimatedTotalTime = (elapsedTime / current) * total;
    const remainingTime = Math.max(0, estimatedTotalTime - elapsedTime);
    console.log(`Progress: ${percentage}% - Est. remaining time: ${remainingTime.toFixed(1)}s`);
}

function getCPUInfo() {
    try {
        const cpus = os.cpus();
        return cpus[0].model;
    } catch (error) {
        return 'Not found';
    }
}

function getMemoryInfo() {
    try {
        const totalMem = os.totalmem() / (1024 * 1024 * 1024);
        const freeMem = os.freemem() / (1024 * 1024 * 1024);
        return `Total: ${totalMem.toFixed(2)} GB, Free: ${freeMem.toFixed(2)} GB`;
    } catch (error) {
        return 'Not found';
    }
}

console.log('########################');
console.log(new Date().toLocaleString());
console.log('########################');
console.log('CPU Model:', getCPUInfo());
console.log('Memory:', getMemoryInfo());
console.log('OS Release:', os.release() || 'Not found');

let completedDetections = 0;
async function runDetector(d: ObjectDetection) {
    const model = await d.getDetectionModel();
    console.log('Model', model);
    const bytes = Buffer.alloc(model.inputSize[0] * model.inputSize[1] * 3);
    const media = await sdk.mediaManager.createMediaObject(bytes, 'x-scrypted/x-scrypted-image', {
        sourceId: image.sourceId,
        width: model.inputSize[0],
        height: model.inputSize[1],
        ffmpegFormats: true,
        format: null,
        toBuffer: async (options) => bytes,
        toImage: undefined,
        close: () => image.close(),
    })
    const start = Date.now();
    let detections = 0;
    const totalDetections = simulatedCameras * batchesPerCamera * batch;

    console.log("Starting benchmark...");

    let lastLog = start;
    const simulateCameraDetections = async () => {
        for (let i = 0; i < batchesPerCamera; i++) {
            await Promise.all([
                d.detectObjects(media, { batch }),
                d.detectObjects(media),
                d.detectObjects(media),
                d.detectObjects(media),
            ]);
            detections += batch;
            completedDetections += batch;
            const now = Date.now();
            if (now - lastLog > 3000) {
                lastLog = now;
                logProgress(detections, totalDetections, start);
            }
        }
    };

    const simulated = [];
    for (let i = 0; i < simulatedCameras; i++) {
        simulated.push(simulateCameraDetections());
    }

    await Promise.all(simulated);
}

const start = Date.now();
let totalDetectors = 0;
let clusterDps: number;
await Promise.allSettled(detectors.map(async id => {
    const d = systemManager.getDeviceById<Settings & ObjectDetection & ClusterForkInterface>(id);
    if (!d) {
        console.log(`${id} not found, skipping.`);
        return;
    }

    console.log(`\nStarting ${id}`);
    console.log(`${id} Plugin Version:`, d.info?.version || 'Not found');

    async function runClusterWorkerDetector(clusterWorkerName: string, d: ObjectDetection & Settings) {
        console.log('Settings:');
        try {
            const settings = await d.getSettings();
            for (const setting of settings) {
                console.log(`  ${setting.title}: ${setting.value}`);
            }
        }
        catch (error) {
            console.log('  Unable to retrieve settings');
        }

        await runDetector(d);

        const end = Date.now();
        if (!clusterDps)
            clusterDps = completedDetections / ((end - start) / 1000);

        const ms = end - start;
        console.log(`\n${clusterWorkerName ? clusterWorkerName + ' ' : ''}${id} benchmark complete:`);
        console.log(`Total time: ${ms} ms`);
        const detections = batchesPerCamera * simulatedCameras * batch;
        console.log(`Total detections: ${detections}`);
        console.log(`Detection rate: ${(detections / (ms / 1000)).toFixed(2)} detections per second`);
        totalDetectors++;
    }


```

--------------------------------

### TextToSpeechAudioButton Script

Source: https://scripts.scrypted.app/tts-audio-button.html

Implements a Scrypted device that acts as a switch to play audio through specified speakers. It handles both MediaPlayer and Intercom interfaces.

```typescript
class TextToSpeechAudioButton extends ScryptedDeviceBase implements OnOff, Settings {
    timeout: any;

    constructor(nativeId: string) {
        super(nativeId);
        // make this device a switch so it can be synced.
        setTimeout(() => {
            systemManager.getDeviceById(this.id).setType(ScryptedDeviceType.Switch);
        });
    }

    async turnOn() {
        const str = this.getJSON('audio') as string || 'Hello World';
        const text = await mediaManager.createMediaObject(str, 'text/plain');
        const audioBuffer = await mediaManager.convertMediaObjectToBuffer(text, 'audio/*');

        this.on = true;

        const ids = this.getJSON('speakers') as string[];
        for (const id of ids) {
            // media players will play back the audio file in real time
            const speaker = systemManager.getDeviceById<MediaPlayer & Intercom & StartStop>(id);

            const mo = await mediaManager.createMediaObject(audioBuffer, 'audio/mpeg');

            if (speaker.interfaces.includes(ScryptedInterface.MediaPlayer)) {
                speaker.load(mo, {
                    mimeType: 'audio/mpeg',
                });
            }
            else {
                // intercoms need an ffmpeg flag to force realtime
                const filename = require('crypto').createHash('sha256').update(str).digest('hex');
                const tmp = require('os').tmpdir();
                const dst = require('path').join(tmp, filename + '.mp3');
                require('fs').writeFileSync(dst, audioBuffer);

                const ffmpegInput: FFmpegInput = {
                    inputArguments: [
                        '-re',
                        '-i', dst,
                    ]
                };
                const mo = await mediaManager.createFFmpegMediaObject(ffmpegInput);
                speaker.startIntercom(mo);
            }
        }

        clearTimeout(this.timeout);
        const duration = this.getJSON('duration') as any;
        if (duration !== '0')
            this.timeout = setTimeout(() => this.turnOff(), (parseFloat(duration) || 10) * 1000);
    }

    async turnOff() {
        this.on = false;
        const ids = this.getJSON('speakers') as string[];
        for (const id of ids) {
            const speaker = systemManager.getDeviceById<MediaPlayer & Intercom & StartStop>(id);

            if (speaker.interfaces.includes(ScryptedInterface.MediaPlayer)) {
                await speaker.stop();
            }
            else {
                await speaker.stopIntercom();
            }
        }
    }

    async getSettings(): Promise<Setting[]> {
        return [
            {
                title: 'Audio Text',
                description: 'The path or URL of the audio to play back.',
                key: 'audio',
                value: this.getJSON('audio') || "Hello World",
            },
            {
                title: 'Speakers',
                key: 'speakers',
                value: this.getJSON('speakers') || [],
                type: 'device',
                multiple: true,
                deviceFilter: `interfaces.includes("${ScryptedInterface.Intercom}") || interfaces.includes("${ScryptedInterface.MediaPlayer}")`,
            },
            {
                title: 'Duration',
                key: 'duration',
                value: this.getJSON('duration') || 10,
                type: 'number',
                description: 'Duration in seconds to play the sound on the speaker.',
            }
        ]
    }

    async putSetting(key: string, value: SettingValue) {
        this.storage.setItem(key, JSON.stringify(value));
        deviceManager.onDeviceEvent(this.nativeId, ScryptedInterface.Settings, undefined);
    }

    getJSON(key: string): SettingValue {
        try {
            return JSON.parse(this.storage.getItem(key));
        } catch (e) {
            return;
        }
    }
}

export default TextToSpeechAudioButton;

```

--------------------------------

### OpenAI Mixin Provider Configuration

Source: https://scripts.scrypted.app/openai-notifications.html

This class defines the Scrypted device mixin provider for OpenAI notifications. It includes storage settings for selecting the LLM provider and configuring the system prompt.

```typescript
export default class OpenAIMixinProvider extends ScryptedDeviceBase implements MixinProvider {
    storageSettings = new StorageSettings(this, {
        chatCompletion: {
            title: 'LLM Provider',
            description: 'Select the LLM provider. Install the LLM plugin to add an external provider or run a local LLM server.',
            type: 'device',
            deviceFilter: ({ScryptedInterface, interfaces}) => {
                return interfaces.includes(ScryptedInterface.ChatCompletion);
            },
        },
        systemPrompt: {
            title: 'System Prompt',
            type: 'textarea',

```

--------------------------------

### Extension Toggle Script

Source: https://scripts.scrypted.app/extension-toggle.html

This script automates toggling extensions on devices. It requires configuration of target devices and the extension to be toggled.

```typescript
class ExtensionToggler extends ScryptedDeviceBase implements Settings, OnOff {
    constructor(nativeId: string) {
        super(nativeId);
        // make this device a switch so it can be synced.
        setTimeout(() => {
            systemManager.getDeviceById(this.id).setType(ScryptedDeviceType.Switch);
        });
    }

    async getSettings(): Promise<Setting[]> {
        return [
            {
                key: 'devices',
                type: 'device',
                title: 'Devices',
                description: 'The devices on which the extension will be toggled.',
                multiple: true,
                value: this.getJSON('devices'),
            },
            {
                key: 'extension',
                type: 'device',
                title: 'Extension',
                description: 'The extension to toggle.',
                deviceFilter: `interfaces.includes('${ScryptedInterface.MixinProvider}')`,
                value: this.getJSON('extension'),
            },
        ]
    }

    async putSetting(key: string, value: SettingValue): Promise<void> {
        this.storage.setItem(key, JSON.stringify(value));
        this.onDeviceEvent(ScryptedInterface.Settings, undefined);
    }

    async turnOff(): Promise<void> {
        const ids = this.getJSON('devices') as string[];
        const extension = this.getJSON('extension');
        for (const id of ids) {
            const device = systemManager.getDeviceById(id);
            if (!device) {
                this.console.log('Device is missing:', id);
                continue;
            }
            device.setMixins(device.mixins.filter(m => m !== extension));
        }
        this.on = false;
    }

    async turnOn(): Promise<void> {
        const ids = this.getJSON('devices') as string[];
        const extension = this.getJSON('extension') as string;
        for (const id of ids) {
            const device = systemManager.getDeviceById(id);
            if (!device) {
                this.console.log('Device is missing:', id);
                continue;
            }
            device.setMixins([...device.mixins, extension]);
        }
        this.on = true;
    }

    getJSON(key: string): SettingValue {
        try {
            return JSON.parse(this.storage.getItem(key));
        }
        catch (e) {
            return [];
        }
    }
}

export default ExtensionToggler;

```

--------------------------------

### OpenAI Notifier System Prompt

Source: https://scripts.scrypted.app/openai-notifications.html

The system prompt defines the instructions for the AI to generate a notification description based on an image. It specifies what to describe (people, animals, vehicles) and what to avoid (scenery, static objects, directing user interaction). It can also use original notification metadata for context.

```typescript
            description: 'Create a notification suitable description of the image provided by the user. Describe the people, animals (coloring and breed), or vehicles (color and model) in the image. Do not describe scenery or static objects. Do not direct the user to click the notification. The original notification metadata may be provided and can be used to provide additional context for the new notification, but should not be used verbatim.',
        }
```

--------------------------------

### Set Video Text Overlay

Source: https://scripts.scrypted.app/temperature-overlay.html

Applies the formatted temperature display value as a text overlay on a given camera. It manages overlay IDs, fetching them if not already known and handling errors.

```typescript
cameras.forEach(async camera => {
            let overlayId = this.overlayIds.get(camera.id);
            if (!overlayId) {
                overlayId = (async () => {
                    const overlays = await camera.getVideoTextOverlays();
                    for (const check of this.storageSettings.values.overlayIds) {
                        if (overlays[check])
                            return check;
                    }
                    this.console.warn(camera.name, 'overlay id not found. Available ids:', overlays);
                    throw new Error('overlay id not found.');
                })()
                    .catch(e => {
                        this.console.warn('Overlay ID error for', camera.name, e);
                        this.overlayIds.delete(camera.id);
                    });
                this.overlayIds.set(camera.id, overlayId);
            }

            const oid = await overlayId;
            camera.setVideoTextOverlay(oid, {
                text: displayValue,
            });
        });
```

--------------------------------

### OpenAI Provider Class

Source: https://scripts.scrypted.app/openai-notifications.html

This TypeScript class, `OpenAIProvider`, handles the core logic for OpenAI notifications. It includes methods for retrieving and updating settings, and for managing mixins, specifically for devices implementing the Notifier interface.

```typescript
    getSettings() {
        return this.storageSettings.getSettings();
    }

    putSetting(key: string, value: SettingValue): Promise<void> {
        return this.storageSettings.putSetting(key, value);
    }


    async canMixin(type: ScryptedDeviceType, interfaces: string[]) {
        if (type === ScryptedDeviceType.Notifier && interfaces?.includes(ScryptedInterface.Notifier))
            return [ScryptedInterface.Notifier];
    }

    async getMixin(mixinDevice: any, mixinDeviceInterfaces: ScryptedInterface[], mixinDeviceState: WritableDeviceState): Promise<any> {
        const ret = new OpenAINotifier({
            mixinDevice,
            mixinDeviceInterfaces,
            mixinDeviceState,
            mixinProviderNativeId: this.nativeId,
        });
        ret.openaiProvider = this;
        return ret;
    }

    async releaseMixin(id: string, mixinDevice: any): Promise<void> {
    }
}
```

--------------------------------

### Play Audio Button Script

Source: https://scripts.scrypted.app/play-audio-button.html

This TypeScript script defines a Scrypted device that acts as a switch to play audio files on specified speakers. It handles both MediaPlayer and Intercom interfaces, with options for audio source, target speakers, and playback duration. The script also manages device settings for configuration.

```typescript
class PlayAudioButton extends ScryptedDeviceBase implements OnOff, Settings {
    timeout: any;

    constructor(nativeId: string) {
        super(nativeId);
        // make this device a switch so it can be synced.
        setTimeout(() => {
            systemManager.getDeviceById(this.id).setType(ScryptedDeviceType.Switch);
        });
    }

    async turnOn() {
        const audio = this.getJSON('audio') as string || 'https://download.samplelib.com/mp3/sample-12s.mp3';
        this.on = true;

        const ids = this.getJSON('speakers') as string[];
        for (const id of ids) {
            const speaker = systemManager.getDeviceById<MediaPlayer & Intercom & StartStop>(id);

            if (speaker.interfaces.includes(ScryptedInterface.MediaPlayer)) {
                speaker.load(audio, {
                    mimeType: 'audio/mp3',
                });
            }
            else {

                const mo = await mediaManager.createFFmpegMediaObject({
                    inputArguments: [
                        '-analyzeduration', '0',
                        '-re',
                        '-i', audio,
                    ]
                });
                
                speaker.startIntercom(mo)
            }
        }

        clearTimeout(this.timeout);
        const duration = this.getJSON('duration') as any;
        if (duration !== '0')
            this.timeout = setTimeout(() => this.turnOff(), (parseFloat(duration) || 10) * 1000);
    }

    async turnOff() {
        this.on = false;
        const ids = this.getJSON('speakers') as string[];
        for (const id of ids) {
            const speaker = systemManager.getDeviceById<MediaPlayer & Intercom & StartStop>(id);

            if (speaker.interfaces.includes(ScryptedInterface.MediaPlayer)) {
                await speaker.stop();
            }
            else {
                await speaker.stopIntercom();
            }
        }
    }

    async getSettings(): Promise<Setting[]> {
        return [
            {
                title: 'Audio File',
                description: 'The path or URL of the audio to play back.',
                key: 'audio',
                value: this.getJSON('audio') || "https://download.samplelib.com/mp3/sample-12s.mp3",
            },
            {
                title: 'Speakers',
                key: 'speakers',
                value: this.getJSON('speakers') || [],
                type: 'device',
                multiple: true,
                deviceFilter: `interfaces.includes("${ScryptedInterface.Intercom}") || interfaces.includes("${ScryptedInterface.MediaPlayer}")`,
            },
            {
                title: 'Duration',
                key: 'duration',
                value: this.getJSON('duration') || 10,
                type: 'number',
                description: 'Duration in seconds to play the sound on the speaker.',
            }
        ]
    }

    async putSetting(key: string, value: SettingValue) {
     this.storage.setItem(key, JSON.stringify(value));
        deviceManager.onDeviceEvent(this.nativeId, ScryptedInterface.Settings, undefined);
    }

    getJSON(key: string): SettingValue {
        try {
            return JSON.parse(this.storage.getItem(key));
        } catch (e) {
            return;
        }
    }
}

export default PlayAudioButton;

```

--------------------------------

### PTZSpeed Mixin Implementation

Source: https://scripts.scrypted.app/ptz-speed.html

This TypeScript class extends `SettingsMixinDeviceBase` to implement PTZ speed adjustments. It modifies incoming `ptzCommand` calls by scaling the pan, tilt, and zoom values based on stored settings. Use negative values in settings to reverse the direction of movement.

```typescript
class PTZSpeedMixin extends SettingsMixinDeviceBase<PanTiltZoom> implements Settings, PanTiltZoom {
    storageSettings = new StorageSettings(this, {
        panSpeed: {
            group: 'PTZ Speed',
            title: 'Pan Speed',
            description: 'The amount to scale the speed. Use negative numbers to reverse the direction.',
            type: 'number',
            defaultValue: 1,
        },
        tiltSpeed: {
            group: 'PTZ Speed',
            title: 'Tilt Speed',
            description: 'The amount to scale the speed. Use negative numbers to reverse the direction.',
            type: 'number',
            defaultValue: 1,
        },
        zoomSpeed: {
            group: 'PTZ Speed',
            title: 'Zoom Speed',
            description: 'The amount to scale the speed. Use negative numbers to reverse the direction.',
            type: 'number',
            defaultValue: 1,
        },
    });

    constructor(options: SettingsMixinDeviceOptions<PanTiltZoom>) {
        super(options)
    }

    ptzCommand(command: PanTiltZoomCommand): Promise<void> {
        if (command.pan !== undefined)
            command.pan *= this.storageSettings.values.panSpeed;
        if (command.tilt !== undefined)
            command.tilt *= this.storageSettings.values.tiltSpeed;
        if (command.zoom !== undefined)
            command.zoom *= this.storageSettings.values.zoomSpeed;
        return this.mixinDevice.ptzCommand(command);
    }

    getMixinSettings(): Promise<Setting[]> {
        return this.storageSettings.getSettings();
    }

    putMixinSetting(key: string, value: SettingValue): Promise<void> {
        return this.storageSettings.putSetting(key, value);
    }
}
```

--------------------------------

### PTZSpeed Mixin Provider

Source: https://scripts.scrypted.app/ptz-speed.html

This TypeScript class acts as a MixinProvider for Scrypted, enabling the PTZSpeedMixin to be applied to devices. It defines how the mixin can be applied based on device interfaces and how to instantiate the mixin.

```typescript
export default class PTZSpeed extends ScryptedDeviceBase implements MixinProvider {
    async canMixin(type: ScryptedDeviceType, interfaces: string[]): Promise<void | string[]> {
        if (interfaces.includes(ScryptedInterface.PanTiltZoom))
            return [ScryptedInterface.PanTiltZoom, ScryptedInterface.Settings];
    }

    async getMixin(mixinDevice: any, mixinDeviceInterfaces: ScryptedInterface[], mixinDeviceState: WritableDeviceState): Promise<any> {
        return new PTZSpeedMixin({
            groupKey: 'ptzSpeed',
            group: 'PTZ Speed',
            mixinDevice,
            mixinDeviceInterfaces,
            mixinDeviceState,
            mixinProviderNativeId: this.nativeId,
        })
    }

    async releaseMixin(id: string, mixinDevice: any): Promise<void> {

    }
}
```

--------------------------------

### OpenAI Notification Sender Implementation

Source: https://scripts.scrypted.app/openai-notifications.html

This class extends Scrypted's MixinDeviceBase to send notifications processed by an OpenAI provider. It handles image conversion to base64 and falls back to standard notification sending if the OpenAI API call fails.

```typescript
class OpenAINotifier extends MixinDeviceBase<Notifier> implements Notifier {
    openaiProvider: OpenAIMixinProvider;

    async sendNotification(title: string, options?: NotifierOptions, media?: string | MediaObject, icon?: string | MediaObject) {
        if (!media)
            return this.mixinDevice.sendNotification(title, options, media, icon);

        let imageUrl: string;
        if (typeof media === 'string') {
            imageUrl = media;
        }
        else {
            const buffer = await mediaManager.convertMediaObjectToBuffer(media, 'image/jpeg');
            const b64 = buffer.toString('base64');
            imageUrl = `data:image/jpeg;base64,${b64}`;
        }

        this.console.log(options);

        const messageTemplate = createMessageTemplate(
            this.openaiProvider.storageSettings.values.systemPrompt,
            imageUrl,
            {
                // title,
                // ...options,
            },
        );

        try {
            const device = this.openaiProvider.storageSettings.values.chatCompletion as ScryptedDevice & ChatCompletion;
            const data = await device.getChatCompletion(messageTemplate);
            const content = data.choices[0].message.content;
            const json = JSON.parse(content);
            this.console.log(json);
            const { title, subtitle, body } = json;

            if (typeof title !== 'string' || typeof subtitle !== 'string' || typeof body !== 'string')
                throw new Error('title or body was not string');

            options ||= {};
            options.body = body;
            options.subtitle = subtitle;

            return await this.mixinDevice.sendNotification(title, options, media, icon);
        }
        catch (e) {
            this.console.warn('OpenAI API call failed. Falling back to standard notification', e);
            return await this.mixinDevice.sendNotification(title, options, media, icon);
        }
    }
}
```

--------------------------------

### Play Confirmation Chime on Doorbell

Source: https://scripts.scrypted.app/face-recognition-unlock.html

Plays an audio file through the doorbell to confirm recognition. Replace 'Doorbell' with your actual doorbell device name.

```typescript
const doorbell = systemManager.getDeviceByName<Intercom>('Doorbell');
const mo = await mediaManager.createFFmpegMediaObject({
    inputArguments: [
        '-re',
        '-i',
        'https://cdn.pixabay.com/download/audio/2023/06/01/audio_77fe776ce5.mp3?filename=simple-notification-152054.mp3',
    ]
});
await doorbell.startIntercom(mo);
```

--------------------------------

### Fetch Forecast Grid Data URL

Source: https://scripts.scrypted.app/temperature-overlay.html

Fetches the forecast grid data URL from the weather API based on latitude and longitude. Handles potential errors during the fetch process.

```typescript
const url = new URL(`https://api.weather.gov/points/${latitude},${longitude}`);
                const response = await fetch(url);
                const json = await response.json();
                return json.properties.forecastGridData;
```

--------------------------------

### Run Object Detection Benchmark Script

Source: https://scripts.scrypted.app/object-detection-benchmark.html

This script checks the cluster mode and either runs a cluster worker detector or iterates through cluster workers to run the detector. It includes error handling for individual worker execution.

```typescript
if (!sdk.clusterManager?.getClusterMode?.()) {
        await runClusterWorkerDetector(undefined, d);
    }
    else {
        const workers = await sdk.clusterManager.getClusterWorkers();
        await Promise.allSettled(Object.values(workers).map(async worker => {
            if (!worker.labels.includes(id))
                return;
            try {
                const forked = await d.forkInterface<ObjectDetection & Settings>(ScryptedInterface.ObjectDetection, {
                    clusterWorkerId: worker.id,
                });
                console.log('Running on cluster worker', worker.name);
                await runClusterWorkerDetector(worker.name, forked);
            }
            catch (e) {
                console.log(`Error running benchmark for ${id}:`, e);
            }
        }));
    }
));

if (sdk.clusterManager?.getClusterMode?.()) {
    const end = Date.now();
    console.log(`
Cluster benchmark complete:`);
    console.log(`Detection rate: ${clusterDps.toFixed(2)} detections per second`);
}
```

--------------------------------

### Process and Display Temperature

Source: https://scripts.scrypted.app/temperature-overlay.html

Retrieves forecast data, converts Celsius to Fahrenheit if specified, and formats the temperature for display. This is used to set the text overlay on cameras.

```typescript
const forecastUrl = await this.forecastUrl;
        const response = await fetch(forecastUrl);
        const json = await response.json();
        let celsiusValue: number = json.properties.temperature.values[0].value;
        let displayValue: string;
        if (this.storageSettings.values.temperatureUnit === 'F') {
            displayValue = Math.round((celsiusValue * (9 / 5))) + 32 + 'F';
        }
        else {
            displayValue = Math.round(celsiusValue * 10) / 10 + 'C';
        }
```

--------------------------------

### NotificationToggle Class

Source: https://scripts.scrypted.app/notification-toggle.html

Main class for the Notification Toggle. It initializes the device as a switch and manages its on/off state. It also handles the mixin logic for notifiers.

```typescript
export default class NotificationToggle extends ScryptedDeviceBase implements MixinProvider, OnOff {
    constructor(nativeId: ScryptedNativeId) {
        super(nativeId);
        // make this device a switch so it can be synced.
        setTimeout(() => {
            systemManager.getDeviceById(this.id).setType(ScryptedDeviceType.Switch);
            if (device.on === undefined) {
                device.on = true;
            }
        }, 1000);
    }

    async turnOff(): Promise<void> {
        this.on = false
    }
    async turnOn(): Promise<void> {
        this.on = true;
    }
    async canMixin(type: ScryptedDeviceType, interfaces: string[]): Promise<string[]> {
        if (!interfaces.includes(ScryptedInterface.Notifier))
            return;
        return [ScryptedInterface.Notifier];
    }

    async getMixin(mixinDevice: any, mixinDeviceInterfaces: ScryptedInterface[], mixinDeviceState: WritableDeviceState): Promise<any> {
        return new NotifierToggleMixin(this, {
            mixinDevice,
            mixinDeviceInterfaces,
            mixinDeviceState,
            mixinProviderNativeId: this.nativeId,
        });
    }

    async releaseMixin(id: string, mixinDevice: any): Promise<void> {
    }
}
```

--------------------------------

### Create Message Template for OpenAI Vision

Source: https://scripts.scrypted.app/openai-notifications.html

This function constructs a message template for OpenAI's vision models, including system prompts, image URLs, and metadata. It specifies a JSON response format with constraints on title, subtitle, and body lengths.

```typescript
function createMessageTemplate(systemPrompt: string, imageUrl: string, metadata: any) {
    const schema = "The response must be in JSON format with a message 'title', 'subtitle', and 'body'. The title and subtitle must not be more than 24 characters each. The body must not be more than 130 characters."
    return {
        messages: [
            {
                role: "system",
                content: systemPrompt + ' ' + schema,
            },
            {
                role: "user",
                content: [
                    {
                        type: 'text',
                        text: `Original notification metadata: ${metadata ? JSON.stringify(metadata) : 'none available'}`,
                    },
                    {
                        type: "image_url",
                        image_url: {
                            url: imageUrl,
                            // url: "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
                            // url: "data:image/jpeg;base64,{base64_image}"
                        }
                    }
                ]
            }
        ],
        response_format: {
            type: "json_schema",
            json_schema: {
                name: "notification_response",
                strict: true,
                schema: {
                    type: "object",
                    properties: {
                        title: {
                            type: "string"
                        },
                        subtitle: {
                            type: "string"
                        },
                        body: {
                            type: "string"
                        }
                    },
                    required: ["title", "subtitle", "body"],
                    additionalProperties: false
                }
            }
        }
    }
}
```
Tokens:
Raw