@camera.ui/browser 0.0.44 → 0.0.45

package/dist/{src → server/src}/camera/streaming/peer-connection.d.ts

@@ -1,16 +1,16 @@
 import { ReplaySubject, Subject } from 'rxjs';
 import { MediaStreamTrack, RTCSessionDescription } from 'werift';
 import { Subscribed } from '../utils/subscribed';
-import type { RtpPacket, RtcpPacket, RTCIceCandidate } from 'werift';
-import type { BasicPeerConnection, BaseLogger, CameraDevice } from '../types';
+import type { RTCIceCandidate, RtcpPacket, RtpPacket } from 'werift';
 import type { IceServer } from '../../services/config/types';
+import type { BaseLogger, BasicPeerConnection, CameraDevice } from '../types';
 export declare class WeriftPeerConnection extends Subscribed implements BasicPeerConnection {
     onAudioRtp: Subject<RtpPacket>;
     onAudioRtcp: Subject<RtcpPacket>;
     onVideoRtp: Subject<RtpPacket>;
     onVideoRtcp: Subject<RtcpPacket>;
     onIceCandidate: Subject<RTCIceCandidate>;
-    onConnectionState: ReplaySubject<"closed" | "failed" | "disconnected" | "new" | "connecting" | "connected">;
+    onConnectionState: ReplaySubject<"closed" | "connected" | "connecting" | "disconnected" | "failed" | "new">;
     returnAudioTrack: MediaStreamTrack;
     private onRequestKeyFrame;
     private cameraDevice;

package/dist/{src → server/src}/camera/streaming/streaming-session.d.ts

@@ -1,8 +1,8 @@
-import { RtpPacket } from 'werift';
 import { ReplaySubject, Subject } from 'rxjs';
+import { RtpPacket } from 'werift';
 import { Subscribed } from '../utils/subscribed';
+import type { BaseLogger, CameraDevice, FfmpegOptions, SpawnInput } from '../types';
 import type { WebrtcConnection } from './webrtc-connection';
-import type { FfmpegOptions, SpawnInput, BaseLogger, CameraDevice } from '../types';
 export declare class StreamingSession extends Subscribed {
     readonly onCallEnded: ReplaySubject<void>;
     readonly onVideoRtp: Subject<RtpPacket>;

package/dist/{src → server/src}/camera/streaming/webrtc-connection.d.ts

@@ -1,8 +1,8 @@
 import { ReplaySubject, Subject, type Observable } from 'rxjs';
 import { Subscribed } from '../utils/subscribed';
 import type { RtpPacket } from 'werift';
-import type { StreamingConnectionOptions, BaseLogger, CameraDevice } from '../types';
 import type { IceServer } from '../../services/config/types';
+import type { BaseLogger, CameraDevice, StreamingConnectionOptions } from '../types';
 export declare class WebrtcConnection extends Subscribed {
     readonly onCameraConnected: ReplaySubject<void>;
     readonly onCallAnswered: ReplaySubject<string>;

package/dist/{src → server/src}/camera/types.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="pouchdb-core" />
 /// <reference types="node" />
 import type { Observable, Subject } from 'rxjs';
-import type { ConnectionState, RTCIceCandidate as WeriftRTCICECandidate, RTCSessionDescription } from 'werift';
-import type { Camera, CameraPublicProperties, CameraInputSettings, CameraZone, CameraInput, CameraType, CameraInformation } from '../api/database/types';
+import type { ConnectionState, RTCSessionDescription, RTCIceCandidate as WeriftRTCICECandidate } from 'werift';
+import type { Camera, CameraInformation, CameraInput, CameraInputSettings, CameraPublicProperties, CameraType, CameraZone } from '../api/database/types';
 import type { IceServer } from '../services/config/types';
-import type { StreamingSession } from './streaming/streaming-session';
 import type { BrowserStreamingSession } from './streaming/browser/browser-streaming-session';
+import type { StreamingSession } from './streaming/streaming-session';
 export type SpawnInput = string | number;
 export type PrebufferType = 'recording' | 'stream';
 export interface CameraSource extends CameraInput {

package/dist/{src → server/src}/go2rtc/index.d.ts

@@ -1,6 +1,8 @@
 import { RUNTIME_STATUS } from '../services/config/types';
 export declare class Go2Rtc {
     private go2rtcProcess?;
+    private prefix;
+    private api;
     private logger;
     private configService;
     version?: string;
@@ -14,7 +16,6 @@ export declare class Go2Rtc {
     constructor();
     start(): Promise<void>;
     stop(): Promise<void>;
-    teardown(): Promise<void>;
     restart(): Promise<void>;
     getPID(): number;
     private kill;

package/dist/{src → server/src}/plugins/index.d.ts

@@ -1,9 +1,4 @@
-/**
- *
- * @url https://github.com/homebridge/homebridge/blob/src/pluginManager.ts
- * (c) Homebridge <https://github.com/homebridge>
- *
- **/
+import 'reflect-metadata';
 import { Plugin } from './plugin';
 import { PluginWorker } from './worker';
 import type { IPackageJson } from '../api/types';
@@ -12,6 +7,7 @@ export declare class PluginManager {
     plugins: Map<string, Plugin>;
     pluginWorkers: Map<string, PluginWorker>;
     searchPaths: Set<string>;
+    private api;
     private configService;
     constructor();
     static isQualifiedPluginIdentifier(pluginName: string): boolean;
@@ -20,15 +16,14 @@ export declare class PluginManager {
     static transformDisplaName(pluginName: string): string;
     static loadPackageJSON(installPath: string): IPackageJson;
     initializeInstalledPlugins(): Promise<void>;
-    initializeInstalledPlugin(plugin: Plugin, insertDb?: boolean): Promise<void>;
+    initializeInstalledPlugin(plugin: Plugin): Promise<void>;
     loadPlugin(absolutePath: string, pluginId?: string, storagePath?: string): Promise<Plugin>;
     removePlugin(plugin: Plugin, removeFromDb?: boolean, removeStorage?: boolean): Promise<void>;
-    startPluginChilds(): Promise<void>;
     startPluginChild(pluginName: string): Promise<void>;
     stopPluginChild(pluginName: string): Promise<void>;
+    private initializePlugins;
     private loadInstalledPlugins;
     private removeOrphanedPlugins;
     private loadDefaultPaths;
     private addNpmPrefixToSearchPaths;
-    private isDependencyForOthers;
 }

package/dist/{src/plugins → server/src/plugins/node}/api.d.ts

@@ -1,15 +1,21 @@
 /// <reference types="node" />
 import EventEmitter from 'events';
-import { DeviceManager, PluginsManager, SystemManager } from '../proxy/client';
+import { DeviceManager, PluginsManager, SystemManager } from './proxy';
 import { StorageController } from './storageController';
-import type { ZmqInfo } from './types';
-import type { Plugin } from './plugin';
-import type { PluginLogger } from '../services/logger';
-import type { BasePlugin } from './base';
+import type { Plugin } from '../plugin';
+import type { BasePlugin, ProxyInfo } from '../types';
 import type { PluginConfigService } from './config';
-export interface API {
+import type { PluginLogger } from './logger';
+export declare interface API {
     on(event: 'finishLaunching', listener: () => void): this;
     on(event: 'shutdown', listener: () => void): this;
+    once(event: 'finishLaunching', listener: () => void): this;
+    once(event: 'shutdown', listener: () => void): this;
+    off(event: 'finishLaunching', listener: () => void): this;
+    off(event: 'shutdown', listener: () => void): this;
+    removeListener(event: 'finishLaunching', listener: () => void): this;
+    removeListener(event: 'shutdown', listener: () => void): this;
+    removeAllListeners(event?: string): this;
     readonly deviceManager: DeviceManager;
     readonly pluginsManager: PluginsManager;
     readonly systemManager: SystemManager;
@@ -27,5 +33,5 @@ export declare class PluginAPI extends EventEmitter implements API {
     readonly storagePath: string;
     readonly configFile: string;
     readonly plugin: BasePlugin;
-    constructor(plugin: Plugin, logger: PluginLogger, proxyData: ZmqInfo);
+    constructor(plugin: Plugin, logger: PluginLogger, proxyData: ProxyInfo);
 }

package/dist/{src/plugins → server/src/plugins/node}/cameraStorage.d.ts

@@ -1,5 +1,5 @@
-import type { API } from './api';
-import type { PluginJsonSchemaForm, PluginJsonSchema, SchemaConfig } from './types';
+import type { PluginJsonSchema, PluginJsonSchemaForm, SchemaConfig } from '../types';
+import type { PluginAPI } from './api';
 export declare class CameraStorage {
     private cameraId;
     private instance;
@@ -8,7 +8,7 @@ export declare class CameraStorage {
     private _schema;
     private _values;
     get values(): Record<string, any>;
-    constructor(api: API, instance: any, cameraId: string, schema?: PluginJsonSchemaForm);
+    constructor(api: PluginAPI, instance: any, cameraId: string, schema?: PluginJsonSchemaForm);
     /**
      * Initialize the storage.
      * This will load the configuration from the database.

package/dist/{src/plugins → server/src/plugins/node}/config.d.ts

@@ -1,5 +1,5 @@
 import { type Path } from 'object-path';
-import type { JSONValue, PluginConfig } from './types';
+import type { JSONValue, PluginConfig } from '../types';
 export declare class PluginConfigService {
     private config;
     private configFile;
@@ -98,16 +98,7 @@ export declare class PluginConfigService {
      * @param write - Optional parameter, if true, the changes will be written to the file.
      */
     replaceOrAddItem(path: string, searchKey: string, searchValue: any, newItem: any, write?: boolean): void;
-    /**
-     * Initialize config.json
-     */
     private init;
-    /**
-     * Read config.json
-     */
     private read;
-    /**
-     * Write config.json
-     */
     private write;
 }

package/dist/server/src/plugins/node/logger.d.ts

@@ -0,0 +1,11 @@
+export declare class PluginLogger {
+    private _loggerPrefix;
+    private get prefix();
+    constructor(prefix: string);
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    attention(...args: any[]): void;
+    debug(...args: any[]): void;
+    trace(...args: any[]): void;
+}

package/dist/{src/proxy/client → server/src/plugins/node/proxy}/cameraDevice.d.ts

@@ -1,9 +1,10 @@
-import { CameraController } from '../../camera';
-import type { Camera } from '../../api/database/types';
-import type { IceServer } from '../../services/config/types';
-import type { ZmqInfo } from '../../plugins/types';
-import type { PluginAPI } from '../../plugins/api';
-import type { StateValues, OnSetEvent, CameraSource } from '../../camera/types';
+import { CameraController } from '../../../camera';
+import type { Camera } from '../../../api/database/types';
+import type { CameraSource, OnSetEvent, StateValues } from '../../../camera/types';
+import type { IceServer } from '../../../services/config/types';
+import type { ProxyInfo } from '../../types';
+import type { PluginAPI } from '../api';
+import type { PluginLogger } from '../logger';
 export declare class CameraDeviceClientProxy extends CameraController {
     private api;
     private logger;
@@ -16,7 +17,7 @@ export declare class CameraDeviceClientProxy extends CameraController {
     private routerAddress;
     private publisherAddress;
     get sources(): CameraSource[];
-    constructor(api: PluginAPI, camera: Camera, pluginId: string, pluginName: string, proxy: ZmqInfo);
+    constructor(api: PluginAPI, logger: PluginLogger, camera: Camera, pluginId: string, pluginName: string, proxy: ProxyInfo);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     reboot(): Promise<void>;

package/dist/server/src/plugins/node/proxy/deviceManager.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { CameraDeviceClientProxy } from './cameraDevice';
+import type { CameraConfig, CameraDevice } from '../../../camera/types';
+import type { DeviceManagerProxyEventCallbacks, DeviceManagerProxyMethods } from '../../../proxy/types';
+import type { ProxyInfo } from '../../types';
+import type { PluginAPI } from '../api';
+import type { PluginLogger } from '../logger';
+export declare interface DeviceManager extends DeviceManagerProxyMethods {
+    on<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof DeviceManagerProxyEventCallbacks>(event?: E): this;
+}
+export declare class DeviceManagerClient extends EventEmitter implements DeviceManager {
+    private api;
+    private logger;
+    private dealer;
+    private subscriber;
+    private messageQueue;
+    private proxy;
+    private pluginId;
+    private pluginName;
+    private dealerId;
+    private subscriberIds;
+    private devices;
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, proxy: ProxyInfo);
+    getCameraById(id: string): Promise<CameraDevice | undefined>;
+    getCameraByName(name: string): Promise<CameraDevice | undefined>;
+    createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
+    removeCameraByName(name: string): Promise<void>;
+    removeCameraById(id: string): Promise<void>;
+    emit(): boolean;
+    on<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof DeviceManagerProxyEventCallbacks>(event?: E): this;
+    configureCameras(cameraDevices: CameraDeviceClientProxy[]): void;
+    private handleRouterRequest;
+    private listenToSubscriberEvents;
+    private onRequest;
+    private addOrGetCamera;
+}

package/dist/server/src/plugins/node/proxy/pluginsManager.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import type { PluginsManagerProxyEventCallbacks, PluginsManagerProxyMethods } from '../../../proxy/types';
+import type { ProxyInfo } from '../../types';
+import type { PluginAPI } from '../api';
+import type { PluginLogger } from '../logger';
+export declare interface PluginsManager extends PluginsManagerProxyMethods {
+    on<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof PluginsManagerProxyEventCallbacks>(event?: E): this;
+}
+export declare class PluginsManagerClient extends EventEmitter implements PluginsManager {
+    private api;
+    private logger;
+    private dealer;
+    private subscriber;
+    private messageQueue;
+    private pluginId;
+    private pluginName;
+    private dealerId;
+    private subscriberIds;
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, proxy: ProxyInfo);
+    emit(): boolean;
+    on<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof PluginsManagerProxyEventCallbacks>(event?: E): this;
+    private handleRouterRequest;
+    private listenToSubscriberEvents;
+    private onRequest;
+    private isPluginMessage;
+    private isStorageMessage;
+}

package/dist/{src/proxy/client → server/src/plugins/node/proxy}/queue.d.ts

@@ -1,5 +1,6 @@
-import { Dealer } from 'zeromq';
-import type { ProxyMessageStructure } from '../types';
+import { Dealer } from '@seydx/zeromq';
+import type { ProxyMessageStructure } from '../../../proxy/types';
+import type { PluginLogger } from '../logger';
 export declare class ClientMessageQueue {
     private logger;
     private dealer;
@@ -8,7 +9,7 @@ export declare class ClientMessageQueue {
     private isProcessing;
     private queue;
     private pendingResponses;
-    constructor(requestHandler: (message: ProxyMessageStructure) => void, dealer: Dealer);
+    constructor(logger: PluginLogger, requestHandler: (message: ProxyMessageStructure) => void, dealer: Dealer);
     abortQueue(): void;
     enqueue(message: ProxyMessageStructure): Promise<any>;
     private processQueue;

package/dist/server/src/plugins/node/proxy/systemManager.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import type { SystemManagerProxyEventCallbacks, SystemManagerProxyMethods } from '../../../proxy/types';
+import type { ProxyInfo } from '../../types';
+import type { PluginAPI } from '../api';
+import type { PluginLogger } from '../logger';
+export declare interface SystemManager extends SystemManagerProxyMethods {
+    on<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof SystemManagerProxyEventCallbacks>(event?: E): this;
+}
+export declare class SystemManagerClient extends EventEmitter implements SystemManager {
+    private api;
+    private logger;
+    private dealer;
+    private subscriber;
+    private messageQueue;
+    private pluginId;
+    private pluginName;
+    private dealerId;
+    private subscriberIds;
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, proxy: ProxyInfo);
+    emit(): boolean;
+    on<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof SystemManagerProxyEventCallbacks>(event?: E): this;
+    private handleRouterRequest;
+    private listenToSubscriberEvents;
+    private onRequest;
+}

package/dist/{src/plugins → server/src/plugins/node}/schema.d.ts

@@ -1,5 +1,5 @@
-import { type ZodTypeAny, z } from 'zod';
-import type { RootSchema, JsonSchema, JsonSchemaString, JsonSchemaAnyOf, JsonSchemaArray, JsonSchemaBoolean, JsonSchemaButton, JsonSchemaEnum, JsonSchemaNumber, JsonSchemaObject, JsonSchemaObjectWithButtons, PluginJsonSchema, PluginRootSchema, PluginJsonSchemaForm } from './types';
+import { z, type ZodTypeAny } from 'zod';
+import type { JsonSchema, JsonSchemaAnyOf, JsonSchemaArray, JsonSchemaBoolean, JsonSchemaButton, JsonSchemaEnum, JsonSchemaNumber, JsonSchemaObject, JsonSchemaObjectWithButtons, JsonSchemaString, PluginJsonSchema, PluginJsonSchemaForm, PluginRootSchema, RootSchema } from '../types';
 type RootZodSchema = z.ZodObject<Record<string, ZodTypeAny>, 'strict', ZodTypeAny, {
     [x: string]: any;
 }, {
@@ -115,14 +115,14 @@ export declare const generateZodSchema: (jsonSchema: JsonSchema) => ZodAny;
  * @param value - The number for which the JSON schema should be generated.
  * @returns - The generated JSON schema for the number.
  */
-export declare const generateNumberSchema: (value: number) => JsonSchemaNumber;
+export declare const generateNumberSchema: () => JsonSchemaNumber;
 /**
  * Generates a JSON schema for a boolean.
  *
  * @param value - The boolean for which the JSON schema should be generated.
  * @returns - The generated JSON schema for the boolean.
  */
-export declare const genereateBooleanSchema: (value: boolean) => JsonSchemaBoolean;
+export declare const genereateBooleanSchema: () => JsonSchemaBoolean;
 /**
  * Generates a JSON schema for a string.
  *

package/dist/{src/plugins → server/src/plugins/node}/storageController.d.ts

@@ -1,10 +1,10 @@
 import { CameraStorage } from './cameraStorage';
-import type { API } from './api';
-import type { PluginJsonSchemaForm } from './types';
+import type { PluginJsonSchemaForm } from '../types';
+import type { PluginAPI } from './api';
 export declare class StorageController {
     private api;
     private cameraStorages;
-    constructor(api: API);
+    constructor(api: PluginAPI);
     /**
      * Create a camera storage instance
      *

package/dist/{src → server/src}/plugins/plugin.d.ts

@@ -4,9 +4,10 @@
  * (c) Homebridge <https://github.com/homebridge>
  *
  **/
-import { PluginConfigService } from './config';
+import { PythonInstaller } from '../../bin/python';
+import { PluginConfigService } from './node/config';
 import type { PluginConstructor } from '../api';
-import type { IPackageJson, CameraUiPlugin } from '../api/types';
+import type { CameraUiPlugin, IPackageJson } from '../api/types';
 import type { PluginContract } from './types';
 export interface Context {
     engines?: Record<string, string>;
@@ -16,24 +17,27 @@ export interface Context {
  * Represents a loaded camera.ui plugin.
  */
 export declare class Plugin {
-    private _disabled;
     private logger;
     private configService;
+    private _disabled;
     private _info;
     private _contract;
+    readonly main: string;
     readonly id: string;
     readonly pluginName: string;
     readonly displayName: string;
     readonly scope?: string;
-    private readonly isESM;
-    config: PluginConfigService;
+    readonly isPython: boolean;
+    readonly isESM: boolean;
     readonly isSymLink: boolean;
     readonly installPath: string;
+    readonly pythonInstallPath: string;
     readonly configFile: string;
     readonly storagePath: string;
-    private readonly main;
-    private loadContext?;
+    readonly py: PythonInstaller;
+    readonly config: PluginConfigService;
     pluginConstructor?: PluginConstructor;
+    private loadContext?;
     get contract(): PluginContract;
     get info(): CameraUiPlugin;
     set info(value: CameraUiPlugin);
@@ -41,6 +45,7 @@ export declare class Plugin {
     set disabled(value: boolean);
     constructor(pluginName: string, installPath: string, packageJSON: IPackageJson, pluginId: string, scope?: string, storagePath?: string);
     load(): Promise<void>;
-    reparsePackageJson(): CameraUiPlugin;
+    reparsePackageJson(): void;
     private parsePackageJson;
+    private parseContract;
 }

package/dist/{src → server/src}/plugins/types.d.ts

@@ -1,7 +1,5 @@
 import type { Camera } from '../api/database/types';
-export type PluginGraph = Map<string, string[]>;
-export type PluginCycles = Map<string, string[]>;
-export type PluginGroups = Map<string, string[]>;
+import type { CameraDevice } from '../camera/types';
 export interface SchemaConfig {
     rootSchema: PluginRootSchema;
     config: Record<string, any>;
@@ -26,6 +24,7 @@ export interface PluginContractBase {
     pluginName: string;
     builtIns?: Exclude<CameraExtension, 'hub'>[];
     dependencies?: string[];
+    pythonVersion?: string;
 }
 export type PluginContract = PluginContractBase & ExtensionOrSupport;
 export declare const enum PLUGIN_STATUS {
@@ -45,14 +44,15 @@ export type ProcessErrorMessage = string;
 export interface PluginStorage {
     installPath: string;
     storagePath: string;
+    configFile: string;
 }
-export interface ZmqInfo {
-    zmqRouterAddress: string;
-    zmqPubAddress: string;
-    zmqPublicKey: string;
+export interface ProxyInfo {
+    routerAddress: string;
+    pubAddress: string;
+    publicKey: string;
 }
 export interface ProcessLoadMessage {
-    zmqInfo: ZmqInfo;
+    proxyInfo: ProxyInfo;
     cameras: Camera[];
     pluginId: string;
     storage: PluginStorage;
@@ -160,4 +160,10 @@ export interface RootSchema {
 export interface PluginRootSchema {
     schema: PluginJsonSchemaForm;
 }
+export interface BasePlugin {
+    onFormSubmit(actionId: string, payload: any): Promise<{
+        toast?: string;
+    } | void>;
+    configureCameras(cameras: CameraDevice[]): void;
+}
 export {};

package/dist/server/src/plugins/worker-ipc.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import type { ProcessMessage, ProcessResponse } from './types';
+export declare interface WorkerIPC {
+    on(event: 'message', listener: (message: ProcessResponse) => void): this;
+}
+export declare class WorkerIPC extends EventEmitter {
+    private ipc?;
+    private id;
+    get address(): string | null | undefined;
+    constructor(id: string);
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    sendMessage(message: ProcessMessage): Promise<void>;
+    private listenToChild;
+}

package/dist/{src → server/src}/plugins/worker.d.ts

@@ -1,8 +1,10 @@
-import { PLUGIN_STATUS } from './types';
 import type { Plugin } from './plugin';
+import { PLUGIN_STATUS } from './types';
 export declare class PluginWorker {
     plugin: Plugin;
     private pluginWorker?;
+    private proxyServer;
+    private ipc;
     private api;
     private logger;
     private configService;
@@ -22,5 +24,7 @@ export declare class PluginWorker {
     private setStatus;
     private sendMessage;
     private handleClose;
+    private reset;
     private cleanedProcessEnv;
+    private isLineVisible;
 }

package/dist/{src/proxy/proxies/server.d.ts → server/src/proxy/api.d.ts}

@@ -1,8 +1,8 @@
-import type { ApiProxyMethods, ProxyMessageStructure } from '../types';
-import type { Camera } from '../../api/database/types';
-import type { CameraConfig } from '../../camera/types';
-import type { MessageQueue } from '../queue';
-export declare class ServerProxy implements ApiProxyMethods {
+import type { Camera } from '../api/database/types';
+import type { CameraConfig } from '../camera/types';
+import type { MessageQueue } from './queue';
+import type { ApiProxyMethods, ProxyMessageStructure } from './types';
+export declare class ApiProxy implements ApiProxyMethods {
     private camerasService;
     private pluginsService;
     private messageQueue;

package/dist/{src/proxy/proxies → server/src/proxy}/camera.d.ts

@@ -1,11 +1,10 @@
 /// <reference types="pouchdb-core" />
 /// <reference types="node" />
-import type { OnSetEvent, StateValues, StreamInfo } from '../../camera/types';
-import type { IceServer } from '../../services/config/types';
-import type { FfmpegOptions, CameraDelegate, CameraPrebufferDelegate, PrebufferType } from '../../camera/types';
-import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types';
-import type { MessageQueue } from '../queue';
-import type { Camera } from '../../api/database/types';
+import type { Camera } from '../api/database/types';
+import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions, OnSetEvent, PrebufferType, StateValues, StreamInfo } from '../camera/types';
+import type { IceServer } from '../services/config/types';
+import type { MessageQueue } from './queue';
+import type { CameraDeviceProxyMethods, ProxyMessageStructure } from './types';
 export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private api;
     private configService;

package/dist/{src → server/src}/proxy/constants.d.ts

@@ -1,4 +1,4 @@
-import type { SocketOptions, Router, Reply, Publisher, Request, Dealer, Subscriber } from 'zeromq';
+import type { Dealer, Publisher, Reply, Request, Router, SocketOptions, Subscriber } from '@seydx/zeromq';
 export declare const ROUTER_OPTIONS: SocketOptions<Router>;
 export declare const REPLY_OPTIONS: SocketOptions<Reply>;
 export declare const PUBLISHER_OPTIONS: SocketOptions<Publisher>;

package/dist/{src → server/src}/proxy/index.d.ts

@@ -1,18 +1,18 @@
-import { Router, Publisher } from 'zeromq';
-import { ServerProxy } from './proxies/server';
-import { CameraDeviceProxy } from './proxies/camera';
-import { PluginProxy } from './proxies/plugin';
-import type { ProxyBridge } from './ws';
+import { Publisher, Router } from '@seydx/zeromq';
+import { ApiProxy } from './api';
+import { CameraDeviceProxy } from './camera';
+import { PluginProxy } from './plugin';
 import type { StateValues } from '../camera/types';
-import type { DeviceManagerProxyEvents, SystemManagerProxyEvents, PluginsManagerProxyEvents, CameraDeviceListenerMessagePayload } from './types';
+import type { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginsManagerProxyEvents, SystemManagerProxyEvents } from './types';
+import type { ProxyBridge } from './ws';
 export declare class ProxyServer {
-    server?: ServerProxy;
+    api?: ApiProxy;
     camera?: CameraDeviceProxy;
     plugin?: PluginProxy;
-    private configService;
     router: Router;
     publisher: Publisher;
     socketBridge?: ProxyBridge;
+    publicKey?: string;
     private messageQueue;
     constructor();
     initialize(): Promise<void>;

package/dist/{src/proxy/proxies → server/src/proxy}/plugin.d.ts

@@ -1,7 +1,7 @@
-import type { CameraStorage } from '../../plugins/cameraStorage';
-import type { BasePlugin } from '../../plugins/base';
-import type { MethodKeys, ProxyMessageStructure } from '../types';
-import type { MessageQueue } from '../queue';
+import type { CameraStorage } from '../plugins/node/cameraStorage';
+import { type BasePlugin } from '../plugins/types';
+import type { MessageQueue } from './queue';
+import type { MethodKeys, ProxyMessageStructure } from './types';
 export declare class PluginProxy {
     private pluginsService;
     private messageQueue;