@camera.ui/cli 0.0.48 → 0.0.50

package/templates/go/src/main.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	sdk "github.com/seydx/camera-ui-sdk"
+)
+
+// {{pluginName}}Plugin is the main plugin struct.
+type {{pluginName}}Plugin struct {
+	logger  *sdk.Logger
+	api     *sdk.PluginAPI
+	storage *sdk.DeviceStorage
+}
+
+// NewPlugin creates a new plugin instance.
+// This is called by the SDK during plugin initialization.
+func NewPlugin(logger *sdk.Logger, api *sdk.PluginAPI, storage *sdk.DeviceStorage) sdk.Plugin {
+	return &{{pluginName}}Plugin{
+		logger:  logger,
+		api:     api,
+		storage: storage,
+	}
+}
+
+// ConfigureCameras is called on startup with all assigned cameras.
+func (p *{{pluginName}}Plugin) ConfigureCameras(cameras []*sdk.CameraDevice) error {
+	p.logger.Log("Configuring cameras:", len(cameras))
+
+	for _, camera := range cameras {
+		if err := p.OnCameraAdded(camera); err != nil {
+			p.logger.Error("Failed to configure camera:", camera.Name(), err)
+		}
+	}
+
+	return nil
+}
+
+// OnCameraAdded is called when a camera is added/assigned at runtime.
+func (p *{{pluginName}}Plugin) OnCameraAdded(camera *sdk.CameraDevice) error {
+	p.logger.Log("Camera added:", camera.Name())
+	return nil
+}
+
+// OnCameraReleased is called when a camera is removed/unassigned at runtime.
+func (p *{{pluginName}}Plugin) OnCameraReleased(cameraID string) error {
+	p.logger.Log("Camera released:", cameraID)
+	return nil
+}
+
+func main() {
+	sdk.Run(NewPlugin)
+}

package/templates/python/requirements.txt

@@ -1 +1 @@
-camera-ui-python-types==2.0.3
+camera-ui-sdk==1.0.93

package/templates/python/ruff.toml

@@ -32,8 +32,8 @@ exclude = [
 line-length = 110
 indent-width = 4
 
-# Assume Python 3.8
-target-version = "py39"
+# Assume Python 3.11
+target-version = "py311"
 
 [lint]
 # Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.

package/templates/python/src/main.py

@@ -1,54 +1,325 @@
-from camera_ui_python_types import (
+"""
+Sample camera.ui Plugin (Python)
+
+Demonstrates the camera.ui plugin architecture with sensors:
+- MotionSensor: External motion events (webhooks, ONVIF, etc.)
+- LightControl: Controllable light with on/brightness
+- ClassifierDetectorSensor: Multi-provider frame-based classification
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from camera_ui_sdk import (
+    API_EVENT,
+    BasePlugin,
     CameraDevice,
-    CameraExtension,
-    CuiPlugin,
-    CuiPluginCapability,
+    ClassifierDetectorSensor,
+    ClassifierResult,
+    Detection,
+    DeviceStorage,
+    JsonSchema,
+    LightControl,
     LoggerService,
+    ModelSpec,
+    MotionSensor,
     PluginAPI,
+    VideoFrameData,
 )
 
+if TYPE_CHECKING:
+    from camera_ui_sdk import SensorType
+
+
+# ============ MOTION SENSOR (External Events) ============
+
+
+class ExampleMotionSensor(MotionSensor):
+    """
+    Example motion sensor for external triggers.
+
+    Use this for external motion sources:
+    - ONVIF camera events
+    - SMTP notifications
+    - Webhook triggers
+    - API polling
+
+    For frame-based detection, extend MotionDetectorSensor instead.
+    """
+
+    def __init__(self, name: str) -> None:
+        super().__init__(name)
+
+    def trigger(self, detections: list[Detection] | None = None) -> None:
+        """Trigger motion from external event."""
+        self.detected = True
+        self.detections = detections or []
+
+    def reset(self) -> None:
+        """Clear motion state."""
+        self.detected = False
+        self.detections = []
+
+
+# ============ LIGHT CONTROL ============
+
+
+class ExampleLightControl(LightControl):
+    """
+    Example light control sensor.
+
+    Bidirectional control sensor - consumers can read and write state.
+    Implements setOn/setBrightness to handle state changes.
+    """
+
+    def __init__(self, camera: CameraDevice, name: str = "Light") -> None:
+        super().__init__(name)
+        self._camera = camera
+
+        # Initialize state
+        self.on = False
+        self.brightness = 100
+
+        # Log state changes
+        self.onPropertyChanged.subscribe(
+            lambda event: self._camera.logger.debug(f"{self.name}: {event['property']} = {event['value']}")
+        )
+
+    @property
+    def storage_schema(self) -> list[JsonSchema]:
+        return [
+            {
+                "type": "number",
+                "key": "defaultBrightness",
+                "title": "Default Brightness",
+                "description": "Default brightness level (0-100)",
+                "defaultValue": 100,
+                "minimum": 0,
+                "maximum": 100,
+                "store": True,
+            },
+            {
+                "type": "boolean",
+                "key": "autoOff",
+                "title": "Auto-Off",
+                "description": "Automatically turn off after timeout",
+                "defaultValue": False,
+                "store": True,
+            },
+        ]
+
+    async def setOn(self, value: bool) -> None:
+        """Called when consumer sets 'on' property."""
+        self._camera.logger.log(f"Light turned {'ON' if value else 'OFF'}")
+        self.on = value
+
+        # Apply default brightness when turning on
+        if value and self.storage:
+            default_brightness = self.storage.values.get("defaultBrightness", 100)
+            self.brightness = default_brightness
+
+    async def setBrightness(self, value: int) -> None:
+        """Called when consumer sets 'brightness' property."""
+        self._camera.logger.log(f"Light brightness: {value}%")
+        self.brightness = value
+
+
+# ============ CLASSIFIER (Multi-Provider Example) ============
+
 
-class SamplePlugin(CuiPlugin):
-    def __init__(self, logger: LoggerService, api: PluginAPI):
-        self.api = api
-        self.logger = logger
+class ExampleClassifier(ClassifierDetectorSensor[dict[str, Any]]):
+    """
+    Example classifier sensor.
+
+    Multi-provider sensor: Multiple classifiers can be registered per camera.
+    Example use cases:
+    - Bird species classifier (triggers on 'bird' from object detection)
+    - Dog breed classifier (triggers on 'dog')
+    - Plant species classifier
+
+    The DetectionCoordinator calls detectClassifications() when triggerLabels are detected.
+    """
+
+    def __init__(self, camera: CameraDevice, name: str = "Classifier") -> None:
+        super().__init__(name)
+        self._camera = camera
+
+    @property
+    def storage_schema(self) -> list[JsonSchema]:
+        return [
+            {
+                "type": "number",
+                "key": "confidenceThreshold",
+                "title": "Confidence Threshold",
+                "description": "Minimum confidence for classifications (0-1)",
+                "defaultValue": 0.5,
+                "minimum": 0.1,
+                "maximum": 1.0,
+                "step": 0.05,
+                "store": True,
+            },
+        ]
+
+    @property
+    def modelSpec(self) -> ModelSpec:
+        """
+        Model specification.
+
+        - input: Frame size and format expected by the model
+        - outputLabels: Labels this classifier can output
+        - triggerLabels: Object labels that trigger classification
+        """
+        return {
+            "input": {
+                "width": 224,
+                "height": 224,
+                "format": "rgb",
+            },
+            # Trigger when object detection finds these labels
+            "triggerLabels": ["animal"],
+        }
+
+    async def detectClassifications(
+        self,
+        frame: VideoFrameData,
+        triggerRegions: list[Detection] | None = None,  # noqa: ARG002
+    ) -> ClassifierResult:
+        """
+        Classify objects in a frame.
+
+        Called by DetectionCoordinator when triggerLabels are detected.
+        The frame is pre-scaled to modelSpec.input dimensions.
+        """
+        threshold = 0.5
+        if self.storage:
+            threshold = self.storage.values.get("confidenceThreshold", 0.5)
+
+        # TODO: Implement your classification model here
+        # Example: Load TensorFlow model and run inference
+        #
+        # predictions = await self.model.classify(frame["data"])
+        # return {
+        #     "detected": len(predictions) > 0,
+        #     "detections": [
+        #         {
+        #             "label": p.label,
+        #             "confidence": p.score,
+        #             "box": triggerRegions[0]["box"] if triggerRegions else {"x": 0, "y": 0, "width": 1, "height": 1},
+        #         }
+        #         for p in predictions
+        #     ],
+        # }
+
+        self._camera.logger.debug(
+            f"Classifying frame {frame['width']}x{frame['height']}, threshold: {threshold}"
+        )
+
+        # Return empty result (placeholder)
+        return {
+            "detected": False,
+            "detections": [],
+        }
+
+    async def destroy(self) -> None:
+        """Cleanup when sensor is destroyed."""
+        # Release model resources if needed
+        pass
+
+
+# ============ PLUGIN ============
+
+
+class SamplePlugin(BasePlugin):
+    """
+    Sample plugin demonstrating camera.ui SDK usage.
+
+    The contract (provides/consumes) is defined in contract.ts.
+    """
+
+    def __init__(self, logger: LoggerService, api: PluginAPI, storage: DeviceStorage[Any]) -> None:
+        super().__init__(logger, api, storage)
+
+        # Maps to track cameras and sensors
         self.cameras: dict[str, CameraDevice] = {}
-        self.model = None
+        self.motion_sensors: dict[str, ExampleMotionSensor] = {}
+        self.light_controls: dict[str, ExampleLightControl] = {}
 
-        self.api.on("finishLaunching", self.start)
-        self.api.on("shutdown", self.stop)
+        # Register lifecycle event handlers
+        self.api.on(API_EVENT.FINISH_LAUNCHING, self._on_finish_launching)
+        self.api.on(API_EVENT.SHUTDOWN, self._on_shutdown)
 
-        self.api.device_manager.on("cameraSelected", self.camera_selected)
-        self.api.device_manager.on("cameraDeselected", self.camera_deselected)
+    async def configureCameras(self, cameraDevices: list[CameraDevice]) -> None:
+        """
+        Configure cameras at startup.
+        Called for cameras already assigned to this plugin.
+        """
+        for camera in cameraDevices:
+            await self._setup_camera(camera)
 
-    async def camera_selected(self, camera: CameraDevice, extension: CameraExtension) -> None:
+    async def onCameraAdded(self, camera: CameraDevice, _sensor_type: SensorType | None = None) -> None:
+        """Called when a camera is selected for this plugin at runtime."""
         self.logger.log(f"Camera selected: {camera.name}")
+        await self._setup_camera(camera)
+
+    async def onCameraReleased(self, cameraId: str) -> None:
+        """Called when a camera is deselected from this plugin."""
+        camera = self.cameras.get(cameraId)
+        if not camera:
+            return
 
+        self.logger.log(f"Camera deselected: {camera.name}")
+
+        # Remove sensors
+        motion = self.motion_sensors.get(cameraId)
+        if motion:
+            await camera.removeSensor(motion.id)
+            del self.motion_sensors[cameraId]
+
+        light = self.light_controls.get(cameraId)
+        if light:
+            await camera.removeSensor(light.id)
+            del self.light_controls[cameraId]
+
+        del self.cameras[cameraId]
+
+    async def _setup_camera(self, camera: CameraDevice) -> None:
+        """Set up sensors for a camera."""
         if camera.id in self.cameras:
             return
 
         self.cameras[camera.id] = camera
 
-    def camera_deselected(self, id: str, extension: CameraExtension) -> None:
-        camera = self.cameras.get(id)
+        # Create motion sensor
+        motion = ExampleMotionSensor(f"Motion - {camera.name}")
+        self.motion_sensors[camera.id] = motion
+        await camera.addSensor(motion)
 
-        if camera:
-            self.logger.log(f"Camera deselected: {self.cameras[id].name}")
-            del self.cameras[id]
+        # Create light control
+        light = ExampleLightControl(camera, f"Light - {camera.name}")
+        self.light_controls[camera.id] = light
+        await camera.addSensor(light)
 
-    def start(self) -> None:
-        self.logger.log("Finished launching plugin")
+        self.logger.log(f"Sensors registered for {camera.name}")
 
-    def stop(self) -> None:
-        self.logger.log("Shutting down plugin")
+        # Example: Trigger motion after 5 seconds (for testing)
+        # import asyncio
+        # asyncio.get_event_loop().call_later(5, motion.trigger)
+
+    def _on_finish_launching(self) -> None:
+        """Called when the plugin has finished launching."""
+        self.logger.log("Plugin started")
 
-    async def configureCameras(self, cameras: list[CameraDevice]) -> None:
-        for camera in cameras:
-            self.cameras[camera.id] = camera
+    def _on_shutdown(self) -> None:
+        """Called when camera.ui is shutting down."""
+        self.logger.log("Shutting down plugin")
 
-    async def getCapabilities(self) -> list[CuiPluginCapability]:
-        return []
+        # Cleanup all sensors
+        self.motion_sensors.clear()
+        self.light_controls.clear()
+        self.cameras.clear()
 
 
 def __main__() -> type[SamplePlugin]:
+    """Plugin entry point - returns the plugin class."""
     return SamplePlugin

package/templates/typescript/contract.ts

@@ -0,0 +1,36 @@
+import { PluginRole, SensorType } from '@camera.ui/sdk';
+
+import type { PluginContract } from '@camera.ui/sdk';
+
+/**
+ * Plugin Contract
+ *
+ * Defines what sensors this plugin provides and consumes.
+ * This is used by camera.ui to determine plugin compatibility.
+ */
+export const contract: PluginContract = {
+  // Plugin display name
+  name: 'Sample Plugin',
+
+  // Plugin role - what this plugin does
+  role: PluginRole.SensorProvider,
+
+  // Sensors this plugin provides (add the sensor types you implement)
+  provides: [
+    SensorType.Motion,
+    SensorType.Light,
+    SensorType.Classifier, // Multi-provider: multiple classifiers per camera
+    // SensorType.Object,     // Object detection
+    // SensorType.Battery,    // Battery level
+    // SensorType.Doorbell,   // Doorbell trigger
+    // SensorType.Contact,    // Contact sensor
+    // SensorType.Siren,      // Siren control
+    // SensorType.Switch,     // Switch control
+    // SensorType.SecuritySystem, // Security system
+  ],
+
+  // Sensors this plugin consumes from other plugins (empty if standalone)
+  consumes: [],
+};
+
+export default contract;

package/templates/typescript/eslint.config.js

@@ -42,7 +42,6 @@ export default [
       '@typescript-eslint/consistent-type-imports': 'error',
       '@typescript-eslint/await-thenable': 'error',
       '@typescript-eslint/no-explicit-any': 'off',
-      '@typescript-eslint/no-unused-vars': ['error'],
       '@typescript-eslint/no-unsafe-assignment': 'off',
       '@typescript-eslint/no-unsafe-member-access': 'off',
       '@typescript-eslint/no-unsafe-argument': 'off',
@@ -90,14 +89,25 @@ export default [
       'eol-last': ['error', 'always'],
       'space-before-function-paren': ['error', { named: 'never' }],
 
-      'no-unused-vars': 'off',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          args: 'all',
+          argsIgnorePattern: '^_',
+          caughtErrors: 'all',
+          caughtErrorsIgnorePattern: '^_',
+          destructuredArrayIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          ignoreRestSiblings: true,
+        },
+      ],
       'no-case-declarations': 'off',
       'no-async-promise-executor': 'off',
       'no-control-regex': 'off',
     },
   },
   {
-    files: ['**/*.js', '**/*.cjs', '**/*.mjs', '*.d.ts', '*.config.ts'],
+    files: ['**/*.js', '**/*.cjs', '**/*.mjs', '*.d.ts', '*.config.ts', 'contract.ts'],
     ...tsLint.configs.disableTypeChecked,
   },
 ];

package/templates/typescript/package.eslint.json

@@ -1,4 +1,4 @@
 {
-  "@typescript-eslint/parser": "^8.31.1",
-  "typescript-eslint": "^8.31.1"
+  "@typescript-eslint/parser": "^8.48.1",
+  "typescript-eslint": "^8.48.1"
 }

package/templates/typescript/package.json

@@ -1,6 +1,6 @@
 {
-  "@camera.ui/types": "^0.0.87",
-  "@types/node": "^22.15.3",
-  "rimraf": "^6.0.1",
-  "typescript": "^5.8.3"
+  "@camera.ui/sdk": "^0.0.3",
+  "@types/node": "^24.10.1",
+  "rimraf": "^6.1.2",
+  "typescript": "5.9.3"
 }

package/templates/typescript/src/index.ts

@@ -1,46 +1,115 @@
-import type { CameraDevice, CuiPlugin, CuiPluginCapability, LoggerService, PluginAPI } from '@camera.ui/types';
+import { API_EVENT, BasePlugin } from '@camera.ui/sdk';
 
-export default class SamplePlugin implements CuiPlugin {
-  public logger: LoggerService;
-  public api: PluginAPI;
+import { ExampleLightControl, ExampleMotionSensor } from './sensor.js';
 
+import type { CameraDevice, DeviceStorage, LightControl, LoggerService, MotionSensor, PluginAPI } from '@camera.ui/sdk';
+
+/**
+ * Sample Plugin
+ *
+ * Demonstrates the camera.ui plugin architecture with sensors:
+ * - MotionSensor: External motion events (webhooks, ONVIF, etc.)
+ * - LightControl: Controllable light with on/brightness
+ *
+ * The contract (provides/consumes) is defined in contract.ts.
+ */
+export default class SamplePlugin extends BasePlugin {
+  // Maps to track cameras and sensors
   private cameras = new Map<string, CameraDevice>();
+  private motionSensors = new Map<string, MotionSensor>();
+  private lightControls = new Map<string, LightControl>();
+
+  constructor(logger: LoggerService, api: PluginAPI, storage: DeviceStorage<any>) {
+    super(logger, api, storage);
+
+    // Register lifecycle event handlers
+    this.api.on(API_EVENT.FINISH_LAUNCHING, this.onFinishLaunching.bind(this));
+    this.api.on(API_EVENT.SHUTDOWN, this.onShutdown.bind(this));
+  }
 
-  constructor(logger: LoggerService, api: PluginAPI) {
-    this.logger = logger;
-    this.api = api;
+  /**
+   * Configure cameras at startup.
+   * Called for cameras already assigned to this plugin.
+   */
+  public async configureCameras(cameras: CameraDevice[]): Promise<void> {
+    for (const camera of cameras) {
+      await this.setupCamera(camera);
+    }
+  }
+
+  /**
+   * Called when a camera is selected for this plugin at runtime.
+   */
+  public async onCameraAdded(camera: CameraDevice): Promise<void> {
+    this.logger.log('Camera selected:', camera.name);
+    await this.setupCamera(camera);
+  }
 
-    this.api.on('finishLaunching', this.start.bind(this));
-    this.api.on('shutdown', this.stop.bind(this));
+  /**
+   * Called when a camera is deselected from this plugin.
+   */
+  public async onCameraReleased(cameraId: string): Promise<void> {
+    const camera = this.cameras.get(cameraId);
+    if (!camera) return;
 
-    this.api.deviceManager.on('cameraSelected', (cameraDevice: CameraDevice) => {
-      this.logger.log('Camera selected:', cameraDevice.name);
+    this.logger.log('Camera deselected:', camera.name);
 
-      if (!this.cameras.has(cameraDevice.id)) {
-        this.cameras.set(cameraDevice.id, cameraDevice);
-      }
-    });
+    // Remove sensors
+    const motion = this.motionSensors.get(cameraId);
+    if (motion) {
+      await camera.removeSensor(motion.id);
+      this.motionSensors.delete(cameraId);
+    }
 
-    this.api.deviceManager.on('cameraDeselected', (cameraId: string) => {
-      const cameraDevice = this.cameras.get(cameraId);
-      if (cameraDevice) {
-        this.logger.log('Camera deselected:', cameraDevice.name);
-        this.cameras.delete(cameraId);
-      }
-    });
+    const light = this.lightControls.get(cameraId);
+    if (light) {
+      await camera.removeSensor(light.id);
+      this.lightControls.delete(cameraId);
+    }
+
+    this.cameras.delete(cameraId);
   }
 
-  public async configureCameras(): Promise<void> {}
+  /**
+   * Set up sensors for a camera.
+   */
+  private async setupCamera(camera: CameraDevice): Promise<void> {
+    if (this.cameras.has(camera.id)) return;
+
+    this.cameras.set(camera.id, camera);
+
+    // Create motion sensor
+    const motion = new ExampleMotionSensor(`Motion - ${camera.name}`);
+    this.motionSensors.set(camera.id, motion);
+    await camera.addSensor(motion);
 
-  public async getCapabilities(): Promise<CuiPluginCapability[]> {
-    return [];
+    // Create light control
+    const light = new ExampleLightControl(camera, `Light - ${camera.name}`);
+    this.lightControls.set(camera.id, light);
+    await camera.addSensor(light);
+
+    this.logger.log(`Sensors registered for ${camera.name}`);
+
+    // Example: Trigger motion after 5 seconds (for testing)
+    // setTimeout(() => motion.trigger(), 5000);
   }
 
-  private start(): void {
+  /**
+   * Called when the plugin has finished launching.
+   */
+  private onFinishLaunching(): void {
     this.logger.log('Plugin started');
   }
 
-  private stop(): void {
+  /**
+   * Called when camera.ui is shutting down.
+   */
+  private async onShutdown(): Promise<void> {
     this.logger.log('Shutting down plugin');
+
+    // Cleanup all sensors
+    this.motionSensors.clear();
+    this.lightControls.clear();
+    this.cameras.clear();
   }
 }