@camera.ui/cli 0.0.49 → 0.0.51

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();
   }
 }

package/templates/typescript/src/sensor.ts

@@ -0,0 +1,207 @@
+import { ClassifierDetectorSensor, LightControl, MotionSensor } from '@camera.ui/sdk';
+
+import type { CameraDevice, ClassifierResult, Detection, JsonSchema, ModelSpec, VideoFrameData } from '@camera.ui/sdk';
+
+// ============ MOTION SENSOR (External Events) ============
+
+/**
+ * Example Motion Sensor
+ *
+ * Use this for external motion sources:
+ * - ONVIF camera events
+ * - SMTP notifications
+ * - Webhook triggers
+ * - API polling
+ *
+ * For frame-based detection, extend MotionDetectorSensor instead.
+ */
+export class ExampleMotionSensor extends MotionSensor {
+  constructor(name: string) {
+    super(name);
+  }
+
+  /**
+   * Trigger motion from external event
+   */
+  trigger(detections: Detection[] = []): void {
+    this.detected = true;
+    this.detections = detections;
+  }
+
+  /**
+   * Clear motion state
+   */
+  reset(): void {
+    this.detected = false;
+    this.detections = [];
+  }
+}
+
+// ============ LIGHT CONTROL ============
+
+/**
+ * Example Light Control
+ *
+ * Bidirectional control sensor - consumers can read and write state.
+ * Implements setOn/setBrightness to handle state changes.
+ */
+export class ExampleLightControl extends LightControl {
+  private cameraDevice: CameraDevice;
+
+  /**
+   * Storage schema for per-sensor configuration
+   * These settings are persisted and shown in the UI.
+   */
+  schema: JsonSchema[] = [
+    {
+      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,
+    },
+  ];
+
+  constructor(camera: CameraDevice, name = 'Light') {
+    super(name);
+    this.cameraDevice = camera;
+
+    // Initialize state
+    this.on = false;
+    this.brightness = 100;
+
+    // Log state changes
+    this.onPropertyChanged.subscribe(({ property, value }) => {
+      this.cameraDevice.logger.debug(`${this.name}: ${property} = ${value}`);
+    });
+  }
+
+  /**
+   * Called when consumer sets 'on' property
+   */
+  async setOn(value: boolean): Promise<void> {
+    this.cameraDevice.logger.log(`Light turned ${value ? 'ON' : 'OFF'}`);
+    this.on = value;
+
+    // Apply default brightness when turning on
+    if (value && this.storage) {
+      const defaultBrightness = this.storage.values.defaultBrightness ?? 100;
+      this.brightness = defaultBrightness;
+    }
+  }
+
+  /**
+   * Called when consumer sets 'brightness' property
+   */
+  async setBrightness(value: number): Promise<void> {
+    this.cameraDevice.logger.log(`Light brightness: ${value}%`);
+    this.brightness = value;
+  }
+}
+
+// ============ CLASSIFIER (Multi-Provider Example) ============
+
+/**
+ * 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.
+ */
+export class ExampleClassifier extends ClassifierDetectorSensor {
+  private cameraDevice: CameraDevice;
+
+  /**
+   * Schema for classifier configuration
+   */
+  schema: JsonSchema[] = [
+    {
+      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,
+    },
+  ];
+
+  constructor(camera: CameraDevice, name = 'Classifier') {
+    super(name);
+    this.cameraDevice = camera;
+  }
+
+  /**
+   * Model specification
+   *
+   * - input: Frame size and format expected by the model
+   * - outputLabels: Labels this classifier can output
+   * - triggerLabels: Object labels that trigger classification
+   */
+  get modelSpec(): ModelSpec {
+    return {
+      input: {
+        width: 224,
+        height: 224,
+        format: 'rgb',
+      },
+      // Trigger when object detection finds these labels
+      triggerLabels: ['animal'],
+    };
+  }
+
+  /**
+   * Classify objects in a frame
+   *
+   * Called by DetectionCoordinator when triggerLabels are detected.
+   * The frame is pre-scaled to modelSpec.input dimensions.
+   */
+  async detectClassifications(frame: VideoFrameData, _triggerRegions?: Detection[]): Promise<ClassifierResult> {
+    const threshold = this.storage?.values.confidenceThreshold ?? 0.5;
+
+    // TODO: Implement your classification model here
+    // Example: Load TensorFlow model and run inference
+    //
+    // const predictions = await this.model.classify(frame.data);
+    // return {
+    //   detected: predictions.length > 0,
+    //   detections: predictions.map(p => ({
+    //     label: p.label,
+    //     confidence: p.score,
+    //     box: triggerRegions?.[0]?.box ?? { x: 0, y: 0, width: 1, height: 1 },
+    //   })),
+    // };
+
+    this.cameraDevice.logger.debug(`Classifying frame ${frame.width}x${frame.height}, threshold: ${threshold}`);
+
+    // Return empty result (placeholder)
+    return {
+      detected: false,
+      detections: [],
+    };
+  }
+
+  /**
+   * Cleanup when sensor is destroyed
+   */
+  async destroy(): Promise<void> {
+    // Release model resources if needed
+  }
+}

package/CHANGELOG.md

@@ -1,8 +0,0 @@
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [X.X.X] - ???
-
-- Initial Release

package/CONTRIBUTING.md

@@ -1 +0,0 @@
-# Contributing

package/scripts/chmod.js

@@ -1,17 +0,0 @@
-import { execSync } from 'node:child_process';
-import { platform } from 'node:os';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const isWindows = platform() === 'win32';
-
-function chmod() {
-  const scriptPath = resolve(__dirname, '../dist/index.js');
-  const arg = isWindows ? 'echo "Skipping chmod command on Windows"' : `chmod +x ${scriptPath}`;
-  execSync(arg, { stdio: 'inherit' });
-}
-
-chmod();

package/templates/base/cameraui.config.js

@@ -1,10 +0,0 @@
-const mode = process.env.MODE || 'production';
-
-const config = {
-  input: ['src/index.js'],
-  mode: mode === 'development' ? 'development' : 'production',
-  external: [],
-  additionalFiles: [],
-};
-
-export default config;

package/templates/base/eslint.config.js

@@ -1,64 +0,0 @@
-import jsLint from '@eslint/js';
-import stylistic from '@stylistic/eslint-plugin';
-import globals from 'globals';
-
-export default [
-  {
-    files: ['**/*.{js,mjs,cjs,ts,mts}'],
-  },
-  {
-    ignores: ['**/dist/**', '**/node_modules/**', '**/public/**', '**/build/**', '**/bundle/**', '**/test/**', '**/wasm/**', '**/example/**'],
-  },
-  jsLint.configs.recommended,
-  stylistic.configs['disable-legacy'],
-  stylistic.configs.customize({
-    indent: 2,
-    quotes: 'single',
-    semi: true,
-    commaDangle: 'always-multiline',
-    jsx: false,
-    arrowParens: true,
-    braceStyle: '1tbs',
-    blockSpacing: true,
-    quoteProps: 'as-needed',
-  }),
-  {
-    languageOptions: {
-      globals: { ...globals.node },
-    },
-
-    rules: {
-      '@stylistic/generator-star-spacing': ['error', { before: true, after: false }],
-
-      // Stylistic specific rules
-      '@stylistic/max-len': ['error', { code: 170, tabWidth: 2 }],
-      '@stylistic/quotes': ['error', 'single', { avoidEscape: true }],
-      '@stylistic/operator-linebreak': 'off',
-      '@stylistic/comma-dangle': [
-        'error',
-        {
-          arrays: 'always-multiline',
-          objects: 'always-multiline',
-          imports: 'always-multiline',
-          exports: 'only-multiline',
-          functions: 'always-multiline',
-          enums: 'always-multiline',
-          generics: 'always-multiline',
-          tuples: 'always-multiline',
-        },
-      ],
-
-      semi: [1, 'always'],
-      // quotes: ['error', 'single'],
-      'comma-dangle': ['error', 'only-multiline'],
-      'no-multiple-empty-lines': ['warn', { max: 1, maxEOF: 0 }],
-      'eol-last': ['error', 'always'],
-      'space-before-function-paren': ['error', { named: 'never' }],
-
-      'no-unused-vars': 'off',
-      'no-case-declarations': 'off',
-      'no-async-promise-executor': 'off',
-      'no-control-regex': 'off',
-    },
-  },
-];

package/templates/base/src/index.js

@@ -1,41 +0,0 @@
-export default class SamplePlugin {
-  constructor(logger, api) {
-    this.logger = logger;
-    this.api = api;
-
-    this.camera = new Map();
-
-    this.api.on('finishLaunching', this.start.bind(this));
-    this.api.on('shutdown', this.stop.bind(this));
-
-    this.api.deviceManager.on('cameraSelected', (cameraDevice) => {
-      this.logger.log('Camera selected:', cameraDevice.name);
-
-      if (!this.cameras.has(cameraDevice.id)) {
-        this.cameras.set(cameraDevice.id, cameraDevice);
-      }
-    });
-
-    this.api.deviceManager.on('cameraDeselected', (cameraId) => {
-      const cameraDevice = this.cameras.get(cameraId);
-      if (cameraDevice) {
-        this.logger.log('Camera deselected:', cameraDevice.name);
-        this.cameras.delete(cameraId);
-      }
-    });
-  }
-
-  async configureCameras() {}
-
-  async getCapabilities() {
-    return [];
-  }
-
-  start() {
-    this.logger.log('Finished launching plugin');
-  }
-
-  stop() {
-    this.logger.log('Shutting down plugin');
-  }
-}