@camera.ui/cli 0.0.49 → 0.0.51

package/templates/go/postinstall.js

@@ -0,0 +1,85 @@
+// postinstall.js — generated by @camera.ui/cli
+const { platform, arch } = require('os');
+const { existsSync, copyFileSync, mkdirSync, chmodSync, readFileSync } = require('fs');
+const { join, dirname } = require('path');
+
+const os = platform();
+const a = arch();
+// Map Node's arch/platform names back to Go's so the right platform package
+// resolves. Most match; the one exception is x64->amd64.
+const goArch = a === 'x64' ? 'amd64' : a;
+const goos = os === 'win32' ? 'windows' : os; // 'linux'/'darwin' match as-is
+const ext = os === 'win32' ? '.exe' : '';
+
+// On Linux, glibc and musl builds ship as separate platform packages (the musl
+// one carries a `-musl` suffix). Detect musl so the matching binary is chosen —
+// a glibc binary can't exec on Alpine/musl and vice versa.
+function isMusl() {
+  if (os !== 'linux') return false;
+  // 1) The process report lists the runtime's shared objects + glibc version.
+  try {
+    if (process.report && typeof process.report.getReport === 'function') {
+      process.report.excludeNetwork = true;
+      const rep = process.report.getReport();
+      if (rep && rep.header && rep.header.glibcVersionRuntime) return false;
+      if (rep && Array.isArray(rep.sharedObjects) && rep.sharedObjects.some((f) => f.includes('libc.musl-') || f.includes('ld-musl-'))) {
+        return true;
+      }
+    }
+  } catch {
+    // fall through to the ldd-based checks
+  }
+  // 2) The dynamic loader on musl systems references musl.
+  try {
+    if (readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')) return true;
+  } catch {
+    // /usr/bin/ldd may not exist — try invoking ldd directly
+  }
+  // 3) Last resort: ask ldd for its version banner.
+  try {
+    if (require('child_process').execSync('ldd --version 2>&1', { encoding: 'utf-8' }).includes('musl')) return true;
+  } catch {
+    // give up — assume glibc
+  }
+  return false;
+}
+
+const key = goos + '-' + goArch + (isMusl() ? '-musl' : '');
+
+const pkg = require('./package.json');
+const pluginName = pkg.name.replace(/^@[^/]+\//, '');
+const scope = pkg.name.includes('/') ? pkg.name.split('/')[0] : undefined;
+const platformPkgName = scope ? scope + '/' + pluginName + '-' + key : pluginName + '-' + key;
+
+let binarySource;
+try {
+  const pkgDir = dirname(require.resolve(platformPkgName + '/package.json'));
+  binarySource = join(pkgDir, pluginName + ext);
+} catch {
+  // The matching platform package isn't installed. Either this platform isn't
+  // supported, or npm skipped the optional dependency (a known npm bug:
+  // https://github.com/npm/cli/issues/4828). Warn but don't fail the install.
+  console.warn(
+    '[' +
+    pluginName +
+    '] no native binary for ' +
+    key +
+    ' (expected package ' +
+    platformPkgName +
+    ').\n' +
+    '  If your platform should be supported, remove node_modules + package-lock.json and reinstall.',
+  );
+  process.exit(0);
+}
+
+if (!existsSync(binarySource)) process.exit(0);
+
+const binDir = join(__dirname, 'dist', 'bin');
+mkdirSync(binDir, { recursive: true });
+const target = join(binDir, 'plugin' + ext);
+copyFileSync(binarySource, target);
+try {
+  chmodSync(target, 0o755);
+} catch {
+  // Ignore chmod errors on platforms that don't support it (e.g. Windows)
+}

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"
 }