matter-all-in-one-addon 1.8.21
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +183 -0
- package/dist/camera/ai/camera-ai-detector.d.ts +44 -0
- package/dist/camera/ai/camera-ai-detector.js +329 -0
- package/dist/camera/ai/camera-ai-detector.js.map +1 -0
- package/dist/camera/camera-capabilities.d.ts +13 -0
- package/dist/camera/camera-capabilities.js +186 -0
- package/dist/camera/camera-capabilities.js.map +1 -0
- package/dist/camera/camera-source-resolver.d.ts +18 -0
- package/dist/camera/camera-source-resolver.js +187 -0
- package/dist/camera/camera-source-resolver.js.map +1 -0
- package/dist/camera/camera-types.d.ts +124 -0
- package/dist/camera/camera-types.js +8 -0
- package/dist/camera/camera-types.js.map +1 -0
- package/dist/camera/cameraui/cameraui-client.d.ts +54 -0
- package/dist/camera/cameraui/cameraui-client.js +698 -0
- package/dist/camera/cameraui/cameraui-client.js.map +1 -0
- package/dist/camera/cameraui/cameraui-homekit-bridge.d.ts +21 -0
- package/dist/camera/cameraui/cameraui-homekit-bridge.js +343 -0
- package/dist/camera/cameraui/cameraui-homekit-bridge.js.map +1 -0
- package/dist/camera/cameraui/cameraui-storage.d.ts +17 -0
- package/dist/camera/cameraui/cameraui-storage.js +916 -0
- package/dist/camera/cameraui/cameraui-storage.js.map +1 -0
- package/dist/camera/cameraui/cameraui-types.d.ts +89 -0
- package/dist/camera/cameraui/cameraui-types.js +5 -0
- package/dist/camera/cameraui/cameraui-types.js.map +1 -0
- package/dist/camera/homekit/ffmpeg-helper.d.ts +88 -0
- package/dist/camera/homekit/ffmpeg-helper.js +673 -0
- package/dist/camera/homekit/ffmpeg-helper.js.map +1 -0
- package/dist/camera/homekit/fmp4-parser.d.ts +48 -0
- package/dist/camera/homekit/fmp4-parser.js +156 -0
- package/dist/camera/homekit/fmp4-parser.js.map +1 -0
- package/dist/camera/homekit/hevc-eligibility.d.ts +16 -0
- package/dist/camera/homekit/hevc-eligibility.js +153 -0
- package/dist/camera/homekit/hevc-eligibility.js.map +1 -0
- package/dist/camera/homekit/homekit-camera-recording.delegate.d.ts +73 -0
- package/dist/camera/homekit/homekit-camera-recording.delegate.js +445 -0
- package/dist/camera/homekit/homekit-camera-recording.delegate.js.map +1 -0
- package/dist/camera/homekit/homekit-camera-stream.delegate.d.ts +47 -0
- package/dist/camera/homekit/homekit-camera-stream.delegate.js +833 -0
- package/dist/camera/homekit/homekit-camera-stream.delegate.js.map +1 -0
- package/dist/camera/homekit/homekit-camera.accessory.d.ts +53 -0
- package/dist/camera/homekit/homekit-camera.accessory.js +697 -0
- package/dist/camera/homekit/homekit-camera.accessory.js.map +1 -0
- package/dist/camera/matter/camera-endpoint.builder.d.ts +7 -0
- package/dist/camera/matter/camera-endpoint.builder.js +127 -0
- package/dist/camera/matter/camera-endpoint.builder.js.map +1 -0
- package/dist/camera/matter/camera-session-manager.d.ts +46 -0
- package/dist/camera/matter/camera-session-manager.js +120 -0
- package/dist/camera/matter/camera-session-manager.js.map +1 -0
- package/dist/camera/matter/camera-webrtc-adapter.d.ts +62 -0
- package/dist/camera/matter/camera-webrtc-adapter.js +298 -0
- package/dist/camera/matter/camera-webrtc-adapter.js.map +1 -0
- package/dist/camera/motion/ffmpeg-motion-detector.d.ts +46 -0
- package/dist/camera/motion/ffmpeg-motion-detector.js +200 -0
- package/dist/camera/motion/ffmpeg-motion-detector.js.map +1 -0
- package/dist/camera/nest/nest-camera-adapter.d.ts +38 -0
- package/dist/camera/nest/nest-camera-adapter.js +109 -0
- package/dist/camera/nest/nest-camera-adapter.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-card.d.ts +39 -0
- package/dist/camera/scrypted/scrypted-camera-card.js +38 -0
- package/dist/camera/scrypted/scrypted-camera-card.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-detail.d.ts +33 -0
- package/dist/camera/scrypted/scrypted-camera-detail.js +34 -0
- package/dist/camera/scrypted/scrypted-camera-detail.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-discovery-adapter.d.ts +17 -0
- package/dist/camera/scrypted/scrypted-camera-discovery-adapter.js +24 -0
- package/dist/camera/scrypted/scrypted-camera-discovery-adapter.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-normalizer.d.ts +44 -0
- package/dist/camera/scrypted/scrypted-camera-normalizer.js +44 -0
- package/dist/camera/scrypted/scrypted-camera-normalizer.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-policy.d.ts +11 -0
- package/dist/camera/scrypted/scrypted-camera-policy.js +13 -0
- package/dist/camera/scrypted/scrypted-camera-policy.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-presentation.d.ts +13 -0
- package/dist/camera/scrypted/scrypted-camera-presentation.js +23 -0
- package/dist/camera/scrypted/scrypted-camera-presentation.js.map +1 -0
- package/dist/camera/scrypted/scrypted-client-discovery-adapter.d.ts +6 -0
- package/dist/camera/scrypted/scrypted-client-discovery-adapter.js +12 -0
- package/dist/camera/scrypted/scrypted-client-discovery-adapter.js.map +1 -0
- package/dist/camera/scrypted/scrypted-client.d.ts +152 -0
- package/dist/camera/scrypted/scrypted-client.js +1170 -0
- package/dist/camera/scrypted/scrypted-client.js.map +1 -0
- package/dist/camera/scrypted/scrypted-crypto.d.ts +21 -0
- package/dist/camera/scrypted/scrypted-crypto.js +90 -0
- package/dist/camera/scrypted/scrypted-crypto.js.map +1 -0
- package/dist/camera/scrypted/scrypted-discovery-provider.d.ts +9 -0
- package/dist/camera/scrypted/scrypted-discovery-provider.js +25 -0
- package/dist/camera/scrypted/scrypted-discovery-provider.js.map +1 -0
- package/dist/camera/scrypted/scrypted-homekit-bridge.d.ts +12 -0
- package/dist/camera/scrypted/scrypted-homekit-bridge.js +214 -0
- package/dist/camera/scrypted/scrypted-homekit-bridge.js.map +1 -0
- package/dist/camera/scrypted/scrypted-matter-bridge.d.ts +36 -0
- package/dist/camera/scrypted/scrypted-matter-bridge.js +226 -0
- package/dist/camera/scrypted/scrypted-matter-bridge.js.map +1 -0
- package/dist/camera/scrypted/scrypted-reconnect-manager.d.ts +40 -0
- package/dist/camera/scrypted/scrypted-reconnect-manager.js +353 -0
- package/dist/camera/scrypted/scrypted-reconnect-manager.js.map +1 -0
- package/dist/camera/scrypted/scrypted-runtime-connector.d.ts +7 -0
- package/dist/camera/scrypted/scrypted-runtime-connector.js +17 -0
- package/dist/camera/scrypted/scrypted-runtime-connector.js.map +1 -0
- package/dist/camera/scrypted/scrypted-runtime-facade.d.ts +13 -0
- package/dist/camera/scrypted/scrypted-runtime-facade.js +29 -0
- package/dist/camera/scrypted/scrypted-runtime-facade.js.map +1 -0
- package/dist/camera/scrypted/scrypted-runtime-ingest.d.ts +5 -0
- package/dist/camera/scrypted/scrypted-runtime-ingest.js +54 -0
- package/dist/camera/scrypted/scrypted-runtime-ingest.js.map +1 -0
- package/dist/camera/scrypted/scrypted-storage.d.ts +95 -0
- package/dist/camera/scrypted/scrypted-storage.js +698 -0
- package/dist/camera/scrypted/scrypted-storage.js.map +1 -0
- package/dist/camera/scrypted/scrypted-stream-validator.d.ts +46 -0
- package/dist/camera/scrypted/scrypted-stream-validator.js +412 -0
- package/dist/camera/scrypted/scrypted-stream-validator.js.map +1 -0
- package/dist/camera/scrypted/scrypted-types.d.ts +354 -0
- package/dist/camera/scrypted/scrypted-types.js +6 -0
- package/dist/camera/scrypted/scrypted-types.js.map +1 -0
- package/dist/converters/binary_sensor.converter.d.ts +18 -0
- package/dist/converters/binary_sensor.converter.js +21 -0
- package/dist/converters/binary_sensor.converter.js.map +1 -0
- package/dist/converters/camera.converter.d.ts +18 -0
- package/dist/converters/camera.converter.js +24 -0
- package/dist/converters/camera.converter.js.map +1 -0
- package/dist/converters/climate.converter.d.ts +21 -0
- package/dist/converters/climate.converter.js +55 -0
- package/dist/converters/climate.converter.js.map +1 -0
- package/dist/converters/cover.converter.d.ts +14 -0
- package/dist/converters/cover.converter.js +22 -0
- package/dist/converters/cover.converter.js.map +1 -0
- package/dist/converters/energy_tariff.converter.d.ts +10 -0
- package/dist/converters/energy_tariff.converter.js +12 -0
- package/dist/converters/energy_tariff.converter.js.map +1 -0
- package/dist/converters/fan.converter.d.ts +233 -0
- package/dist/converters/fan.converter.js +353 -0
- package/dist/converters/fan.converter.js.map +1 -0
- package/dist/converters/index.d.ts +14 -0
- package/dist/converters/index.js +15 -0
- package/dist/converters/index.js.map +1 -0
- package/dist/converters/light.converter.d.ts +26 -0
- package/dist/converters/light.converter.js +36 -0
- package/dist/converters/light.converter.js.map +1 -0
- package/dist/converters/lock.converter.d.ts +20 -0
- package/dist/converters/lock.converter.js +29 -0
- package/dist/converters/lock.converter.js.map +1 -0
- package/dist/converters/sensor.converter.d.ts +18 -0
- package/dist/converters/sensor.converter.js +33 -0
- package/dist/converters/sensor.converter.js.map +1 -0
- package/dist/converters/soil_sensor.converter.d.ts +14 -0
- package/dist/converters/soil_sensor.converter.js +21 -0
- package/dist/converters/soil_sensor.converter.js.map +1 -0
- package/dist/converters/vacuum.converter.d.ts +168 -0
- package/dist/converters/vacuum.converter.js +288 -0
- package/dist/converters/vacuum.converter.js.map +1 -0
- package/dist/device-profiles.d.ts +14 -0
- package/dist/device-profiles.js +245 -0
- package/dist/device-profiles.js.map +1 -0
- package/dist/device-registry.d.ts +58 -0
- package/dist/device-registry.js +288 -0
- package/dist/device-registry.js.map +1 -0
- package/dist/entities/base.entity.d.ts +40 -0
- package/dist/entities/base.entity.js +826 -0
- package/dist/entities/base.entity.js.map +1 -0
- package/dist/entities/camera.entity.d.ts +48 -0
- package/dist/entities/camera.entity.js +127 -0
- package/dist/entities/camera.entity.js.map +1 -0
- package/dist/entities/closure.entity.d.ts +9 -0
- package/dist/entities/closure.entity.js +52 -0
- package/dist/entities/closure.entity.js.map +1 -0
- package/dist/entities/composite-device.entity.d.ts +61 -0
- package/dist/entities/composite-device.entity.js +986 -0
- package/dist/entities/composite-device.entity.js.map +1 -0
- package/dist/entities/cooktop.entity.d.ts +20 -0
- package/dist/entities/cooktop.entity.js +59 -0
- package/dist/entities/cooktop.entity.js.map +1 -0
- package/dist/entities/energy_tariff.entity.d.ts +7 -0
- package/dist/entities/energy_tariff.entity.js +32 -0
- package/dist/entities/energy_tariff.entity.js.map +1 -0
- package/dist/entities/humidifier.entity.d.ts +27 -0
- package/dist/entities/humidifier.entity.js +187 -0
- package/dist/entities/humidifier.entity.js.map +1 -0
- package/dist/entities/lock.entity.d.ts +12 -0
- package/dist/entities/lock.entity.js +58 -0
- package/dist/entities/lock.entity.js.map +1 -0
- package/dist/entities/media-player.entity.d.ts +13 -0
- package/dist/entities/media-player.entity.js +52 -0
- package/dist/entities/media-player.entity.js.map +1 -0
- package/dist/entities/oven.entity.d.ts +20 -0
- package/dist/entities/oven.entity.js +112 -0
- package/dist/entities/oven.entity.js.map +1 -0
- package/dist/entities/pet_feeder.entity.d.ts +28 -0
- package/dist/entities/pet_feeder.entity.js +67 -0
- package/dist/entities/pet_feeder.entity.js.map +1 -0
- package/dist/entities/soil_sensor.entity.d.ts +7 -0
- package/dist/entities/soil_sensor.entity.js +40 -0
- package/dist/entities/soil_sensor.entity.js.map +1 -0
- package/dist/entities/vacuum.entity.d.ts +37 -0
- package/dist/entities/vacuum.entity.js +352 -0
- package/dist/entities/vacuum.entity.js.map +1 -0
- package/dist/frontend/assets/index-DPXu3al2.js +26 -0
- package/dist/frontend/assets/index-DalMl4eS.css +1 -0
- package/dist/frontend/assets/logo-B_gEBugV.png +0 -0
- package/dist/frontend/index.html +14 -0
- package/dist/frontend/logo.png +0 -0
- package/dist/homeAssistant.d.ts +1268 -0
- package/dist/homeAssistant.js +1623 -0
- package/dist/homeAssistant.js.map +1 -0
- package/dist/homekit.compat.d.ts +40 -0
- package/dist/homekit.compat.js +43 -0
- package/dist/homekit.compat.js.map +1 -0
- package/dist/index.d.ts +7 -0
- package/dist/index.js +31 -0
- package/dist/index.js.map +1 -0
- package/dist/mqtt/mqtt-client.d.ts +33 -0
- package/dist/mqtt/mqtt-client.js +138 -0
- package/dist/mqtt/mqtt-client.js.map +1 -0
- package/dist/mqtt/mqtt.entity.d.ts +30 -0
- package/dist/mqtt/mqtt.entity.js +286 -0
- package/dist/mqtt/mqtt.entity.js.map +1 -0
- package/dist/platform.d.ts +318 -0
- package/dist/platform.js +6144 -0
- package/dist/platform.js.map +1 -0
- package/dist/proxy.d.ts +1 -0
- package/dist/proxy.js +226 -0
- package/dist/proxy.js.map +1 -0
- package/dist/utils/ha-discovery.d.ts +30 -0
- package/dist/utils/ha-discovery.js +175 -0
- package/dist/utils/ha-discovery.js.map +1 -0
- package/dist/utils/ha-state.d.ts +48 -0
- package/dist/utils/ha-state.js +21 -0
- package/dist/utils/ha-state.js.map +1 -0
- package/dist/utils/light-color.d.ts +63 -0
- package/dist/utils/light-color.js +213 -0
- package/dist/utils/light-color.js.map +1 -0
- package/dist/utils/log-buffer.d.ts +13 -0
- package/dist/utils/log-buffer.js +50 -0
- package/dist/utils/log-buffer.js.map +1 -0
- package/dist/utils/matter-attributes.d.ts +13 -0
- package/dist/utils/matter-attributes.js +35 -0
- package/dist/utils/matter-attributes.js.map +1 -0
- package/dist/utils/matter-device-identity.d.ts +22 -0
- package/dist/utils/matter-device-identity.js +70 -0
- package/dist/utils/matter-device-identity.js.map +1 -0
- package/dist/utils/thread-credentials.d.ts +22 -0
- package/dist/utils/thread-credentials.js +29 -0
- package/dist/utils/thread-credentials.js.map +1 -0
- package/package.json +80 -0
|
@@ -0,0 +1,1170 @@
|
|
|
1
|
+
import net from "node:net";
|
|
2
|
+
import { isInventedRtspUrl } from "./scrypted-storage.js";
|
|
3
|
+
import { adaptScryptedClientDiscovery, } from "./scrypted-client-discovery-adapter.js";
|
|
4
|
+
import { ScryptedRuntimeFacade } from "./scrypted-runtime-facade.js";
|
|
5
|
+
import { createScryptedRuntimeConnection, } from "./scrypted-runtime-connector.js";
|
|
6
|
+
export class ScryptedClientError extends Error {
|
|
7
|
+
code;
|
|
8
|
+
statusCode;
|
|
9
|
+
constructor(message, code, statusCode) {
|
|
10
|
+
super(message);
|
|
11
|
+
this.name = "ScryptedClientError";
|
|
12
|
+
this.code = code;
|
|
13
|
+
this.statusCode = statusCode;
|
|
14
|
+
Object.setPrototypeOf(this, ScryptedClientError.prototype);
|
|
15
|
+
}
|
|
16
|
+
}
|
|
17
|
+
/**
|
|
18
|
+
* Helper to unwrap Scrypted state property wrappers ({ value: ... })
|
|
19
|
+
* When querying Scrypted's systemState directly, each property is wrapped in an object: { value: ... }
|
|
20
|
+
*/
|
|
21
|
+
export function unwrapScryptedValue(val) {
|
|
22
|
+
if (val !== null && typeof val === "object" && "value" in val) {
|
|
23
|
+
return val.value;
|
|
24
|
+
}
|
|
25
|
+
return val;
|
|
26
|
+
}
|
|
27
|
+
/**
|
|
28
|
+
* Resolves manufacturer/model from Scrypted device info.
|
|
29
|
+
* Returns undefined if not available — callers must handle fallback.
|
|
30
|
+
*/
|
|
31
|
+
function extractDeviceInfo(device) {
|
|
32
|
+
const rawInfo = unwrapScryptedValue(device?.info) ?? {};
|
|
33
|
+
const manufacturer = unwrapScryptedValue(rawInfo.manufacturer) ||
|
|
34
|
+
unwrapScryptedValue(device?.manufacturer) ||
|
|
35
|
+
undefined;
|
|
36
|
+
const model = unwrapScryptedValue(rawInfo.model) ||
|
|
37
|
+
unwrapScryptedValue(device?.model) ||
|
|
38
|
+
undefined;
|
|
39
|
+
// Priority for serial:
|
|
40
|
+
// 1. device.info.serialNumber (manufacturer serial)
|
|
41
|
+
// 2. plugin-provided serial (device.info.serial)
|
|
42
|
+
// 3. nativeId explicitly labeled as technical ID
|
|
43
|
+
// Never use IP address as serial. Never publish MAC automatically as serial by default.
|
|
44
|
+
let serialNumber = unwrapScryptedValue(rawInfo.serialNumber) ||
|
|
45
|
+
unwrapScryptedValue(device?.serialNumber) ||
|
|
46
|
+
undefined;
|
|
47
|
+
if (!serialNumber) {
|
|
48
|
+
const pluginSerial = unwrapScryptedValue(rawInfo.serial) ||
|
|
49
|
+
unwrapScryptedValue(device?.serial);
|
|
50
|
+
if (pluginSerial &&
|
|
51
|
+
typeof pluginSerial === "string" &&
|
|
52
|
+
!net.isIP(pluginSerial)) {
|
|
53
|
+
serialNumber = pluginSerial;
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
if (!serialNumber) {
|
|
57
|
+
const nativeId = unwrapScryptedValue(device?.nativeId);
|
|
58
|
+
if (nativeId &&
|
|
59
|
+
typeof nativeId === "string" &&
|
|
60
|
+
!net.isIP(nativeId) &&
|
|
61
|
+
nativeId.length >= 6) {
|
|
62
|
+
serialNumber = nativeId;
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
if (serialNumber &&
|
|
66
|
+
typeof serialNumber === "string" &&
|
|
67
|
+
net.isIP(serialNumber)) {
|
|
68
|
+
serialNumber = undefined;
|
|
69
|
+
}
|
|
70
|
+
return {
|
|
71
|
+
manufacturer: typeof manufacturer === "string" && manufacturer.trim()
|
|
72
|
+
? manufacturer.trim()
|
|
73
|
+
: undefined,
|
|
74
|
+
model: typeof model === "string" && model.trim() ? model.trim() : undefined,
|
|
75
|
+
serialNumber: typeof serialNumber === "string" && serialNumber.trim()
|
|
76
|
+
? serialNumber.trim()
|
|
77
|
+
: undefined,
|
|
78
|
+
};
|
|
79
|
+
}
|
|
80
|
+
/**
|
|
81
|
+
* Returns true if the Scrypted device exposes camera-related interfaces.
|
|
82
|
+
*/
|
|
83
|
+
function isCameraDevice(device) {
|
|
84
|
+
if (!device || typeof device !== "object")
|
|
85
|
+
return false;
|
|
86
|
+
const rawType = unwrapScryptedValue(device.type);
|
|
87
|
+
const rawProvidedType = unwrapScryptedValue(device.providedType);
|
|
88
|
+
const type = String(rawType || "").toLowerCase();
|
|
89
|
+
const providedType = String(rawProvidedType || "").toLowerCase();
|
|
90
|
+
const rawIfaces = unwrapScryptedValue(device.interfaces);
|
|
91
|
+
const interfaces = Array.isArray(rawIfaces)
|
|
92
|
+
? rawIfaces.map((i) => String(unwrapScryptedValue(i)))
|
|
93
|
+
: [];
|
|
94
|
+
const rawProvidedIfaces = unwrapScryptedValue(device.providedInterfaces);
|
|
95
|
+
const providedInterfaces = Array.isArray(rawProvidedIfaces)
|
|
96
|
+
? rawProvidedIfaces.map((i) => String(unwrapScryptedValue(i)))
|
|
97
|
+
: [];
|
|
98
|
+
const allInterfaces = [...interfaces, ...providedInterfaces];
|
|
99
|
+
return (type.includes("camera") ||
|
|
100
|
+
type.includes("doorbell") ||
|
|
101
|
+
providedType.includes("camera") ||
|
|
102
|
+
providedType.includes("doorbell") ||
|
|
103
|
+
allInterfaces.includes("Camera") ||
|
|
104
|
+
allInterfaces.includes("VideoCamera") ||
|
|
105
|
+
allInterfaces.includes("VideoCameraConfiguration") ||
|
|
106
|
+
allInterfaces.includes("VideoRecorder") ||
|
|
107
|
+
allInterfaces.includes("VideoClips") ||
|
|
108
|
+
allInterfaces.includes("RTCSignalingChannel"));
|
|
109
|
+
}
|
|
110
|
+
/**
|
|
111
|
+
* Maps a Scrypted device to a CameraRecord with real data from the SDK.
|
|
112
|
+
* Streams are marked as 'unverified' — no RTSP URL is constructed or assumed.
|
|
113
|
+
*/
|
|
114
|
+
function mapDeviceToCameraRecord(device, serverUrl, fallbackId) {
|
|
115
|
+
const rawId = unwrapScryptedValue(device.id) ??
|
|
116
|
+
unwrapScryptedValue(device._id) ??
|
|
117
|
+
fallbackId ??
|
|
118
|
+
`scrypted_${Date.now()}_${Math.random().toString(36).slice(2)}`;
|
|
119
|
+
const id = String(rawId);
|
|
120
|
+
const rawName = unwrapScryptedValue(device.name);
|
|
121
|
+
const name = typeof rawName === "string" && rawName.trim().length > 0
|
|
122
|
+
? rawName.trim()
|
|
123
|
+
: `Scrypted Camera ${id}`;
|
|
124
|
+
const { manufacturer, model, serialNumber } = extractDeviceInfo(device);
|
|
125
|
+
const rawIfaces = unwrapScryptedValue(device.interfaces);
|
|
126
|
+
const interfaces = Array.isArray(rawIfaces)
|
|
127
|
+
? rawIfaces.map((i) => String(unwrapScryptedValue(i)))
|
|
128
|
+
: [];
|
|
129
|
+
const rawProvidedIfaces = unwrapScryptedValue(device.providedInterfaces);
|
|
130
|
+
const providedInterfaces = Array.isArray(rawProvidedIfaces)
|
|
131
|
+
? rawProvidedIfaces.map((i) => String(unwrapScryptedValue(i)))
|
|
132
|
+
: [];
|
|
133
|
+
const allInterfaces = [...interfaces, ...providedInterfaces];
|
|
134
|
+
const sensors = [];
|
|
135
|
+
if (allInterfaces.includes("MotionSensor")) {
|
|
136
|
+
sensors.push({
|
|
137
|
+
sensorId: `${id}_motion`,
|
|
138
|
+
type: "motion",
|
|
139
|
+
name: `${name} – Movimiento`,
|
|
140
|
+
enabled: true,
|
|
141
|
+
state: false,
|
|
142
|
+
});
|
|
143
|
+
}
|
|
144
|
+
if (allInterfaces.includes("Doorbell")) {
|
|
145
|
+
sensors.push({
|
|
146
|
+
sensorId: `${id}_doorbell`,
|
|
147
|
+
type: "doorbell",
|
|
148
|
+
name: `${name} – Timbre`,
|
|
149
|
+
enabled: true,
|
|
150
|
+
state: false,
|
|
151
|
+
});
|
|
152
|
+
}
|
|
153
|
+
if (allInterfaces.includes("Light") || allInterfaces.includes("OnOff")) {
|
|
154
|
+
sensors.push({
|
|
155
|
+
sensorId: `${id}_light`,
|
|
156
|
+
type: "light",
|
|
157
|
+
name: `${name} – Luz / Foco`,
|
|
158
|
+
enabled: true,
|
|
159
|
+
state: false,
|
|
160
|
+
});
|
|
161
|
+
}
|
|
162
|
+
if (allInterfaces.includes("Siren") || allInterfaces.includes("Alarm")) {
|
|
163
|
+
sensors.push({
|
|
164
|
+
sensorId: `${id}_siren`,
|
|
165
|
+
type: "siren",
|
|
166
|
+
name: `${name} – Sirena / Alarma`,
|
|
167
|
+
enabled: true,
|
|
168
|
+
state: false,
|
|
169
|
+
});
|
|
170
|
+
}
|
|
171
|
+
let resolvedModel = model ?? undefined;
|
|
172
|
+
if (!resolvedModel && typeof name === "string") {
|
|
173
|
+
const n = name.toLowerCase();
|
|
174
|
+
if (n.includes("pan v3") || n.includes("pan_v3"))
|
|
175
|
+
resolvedModel = "Wyze Cam Pan v3";
|
|
176
|
+
else if (n.includes("pan v2") || n.includes("pan_v2"))
|
|
177
|
+
resolvedModel = "Wyze Cam Pan v2";
|
|
178
|
+
else if (n.includes("cam pan") || (n.includes("pan") && n.includes("wyze")))
|
|
179
|
+
resolvedModel = "Wyze Cam Pan";
|
|
180
|
+
else if (n.includes("c200"))
|
|
181
|
+
resolvedModel = "Tapo C200";
|
|
182
|
+
else if (n.includes("c210"))
|
|
183
|
+
resolvedModel = "Tapo C210";
|
|
184
|
+
else if (n.includes("c220"))
|
|
185
|
+
resolvedModel = "Tapo C220";
|
|
186
|
+
else if (n.includes("c225"))
|
|
187
|
+
resolvedModel = "Tapo C225";
|
|
188
|
+
}
|
|
189
|
+
const isPtz = allInterfaces.includes("PanTilt") ||
|
|
190
|
+
allInterfaces.includes("PanTiltZoom");
|
|
191
|
+
if (isPtz) {
|
|
192
|
+
sensors.push({
|
|
193
|
+
sensorId: `${id}_ptz`,
|
|
194
|
+
type: "ptz",
|
|
195
|
+
name: `${name} – Control PTZ (Giro)`,
|
|
196
|
+
enabled: true,
|
|
197
|
+
state: true,
|
|
198
|
+
});
|
|
199
|
+
}
|
|
200
|
+
const resolvedManufacturer = manufacturer ?? undefined;
|
|
201
|
+
let scryptedHost = "127.0.0.1";
|
|
202
|
+
try {
|
|
203
|
+
if (serverUrl) {
|
|
204
|
+
scryptedHost = new URL(serverUrl).hostname;
|
|
205
|
+
}
|
|
206
|
+
}
|
|
207
|
+
catch { }
|
|
208
|
+
const discoveredDirectUrl = (typeof device.directUrl === "string" && device.directUrl.trim()) ||
|
|
209
|
+
(typeof device.streamUrl === "string" && device.streamUrl.trim()) ||
|
|
210
|
+
(typeof device.rtspUrl === "string" && device.rtspUrl.trim()) ||
|
|
211
|
+
(typeof device.streamReference?.directUrl === "string" &&
|
|
212
|
+
device.streamReference.directUrl.trim()) ||
|
|
213
|
+
undefined;
|
|
214
|
+
const validDirectUrl = discoveredDirectUrl && !isInventedRtspUrl(discoveredDirectUrl, id)
|
|
215
|
+
? discoveredDirectUrl
|
|
216
|
+
: undefined;
|
|
217
|
+
const isHttpUrl = validDirectUrl?.startsWith("http://") ||
|
|
218
|
+
validDirectUrl?.startsWith("https://");
|
|
219
|
+
const streamReference = validDirectUrl
|
|
220
|
+
? {
|
|
221
|
+
protocol: (isHttpUrl ? "https" : "rtsp"),
|
|
222
|
+
directUrl: validDirectUrl,
|
|
223
|
+
validationStatus: "not_checked",
|
|
224
|
+
}
|
|
225
|
+
: undefined;
|
|
226
|
+
return {
|
|
227
|
+
cameraId: id,
|
|
228
|
+
sourceId: `scrypted_${id}`,
|
|
229
|
+
deviceId: id,
|
|
230
|
+
name,
|
|
231
|
+
enabled: true,
|
|
232
|
+
sourceManufacturer: resolvedManufacturer,
|
|
233
|
+
sourceModel: resolvedModel,
|
|
234
|
+
model: resolvedModel, // compat
|
|
235
|
+
displayManufacturer: resolvedManufacturer ?? "Marca no identificada",
|
|
236
|
+
displayModel: resolvedModel,
|
|
237
|
+
displaySerialNumber: serialNumber || "Serial no disponible",
|
|
238
|
+
serialNumber: serialNumber || undefined,
|
|
239
|
+
identity: {},
|
|
240
|
+
source: {
|
|
241
|
+
kind: "scrypted",
|
|
242
|
+
serverId: serverUrl,
|
|
243
|
+
deviceId: id,
|
|
244
|
+
streamReference,
|
|
245
|
+
snapshotReference: device.snapshotReference ?? undefined,
|
|
246
|
+
profiles: Array.isArray(device.profiles) ? device.profiles : undefined,
|
|
247
|
+
},
|
|
248
|
+
capabilities: {
|
|
249
|
+
// No capabilities are assumed. Marked unverified until validated.
|
|
250
|
+
qualityMode: "maximum_compatible",
|
|
251
|
+
allowAutomaticFallback: false,
|
|
252
|
+
},
|
|
253
|
+
sensors,
|
|
254
|
+
exportConfig: {
|
|
255
|
+
matterEnabled: true,
|
|
256
|
+
homeKitEnabled: true,
|
|
257
|
+
hksvEnabledByDefault: true,
|
|
258
|
+
googleHomeEnabled: false,
|
|
259
|
+
alexaEnabled: false,
|
|
260
|
+
smartThingsEnabled: false,
|
|
261
|
+
nasEnabled: false,
|
|
262
|
+
},
|
|
263
|
+
status: {
|
|
264
|
+
connection: typeof unwrapScryptedValue(device.online) === "boolean"
|
|
265
|
+
? unwrapScryptedValue(device.online)
|
|
266
|
+
? "online"
|
|
267
|
+
: "offline"
|
|
268
|
+
: "online",
|
|
269
|
+
isOnline: typeof unwrapScryptedValue(device.online) === "boolean"
|
|
270
|
+
? Boolean(unwrapScryptedValue(device.online))
|
|
271
|
+
: true,
|
|
272
|
+
cache: "unverified",
|
|
273
|
+
lastFetched: new Date().toISOString(),
|
|
274
|
+
},
|
|
275
|
+
};
|
|
276
|
+
}
|
|
277
|
+
/**
|
|
278
|
+
* ScryptedClient — official SDK-based client for Scrypted integration.
|
|
279
|
+
*
|
|
280
|
+
* Authentication uses `@scrypted/client` exclusively:
|
|
281
|
+
* - `loginScryptedClient` tests credentials via POST /login internally.
|
|
282
|
+
* - `connectScryptedClient` establishes a full WebSocket/RPC session.
|
|
283
|
+
*
|
|
284
|
+
* No manual HTTP Basic Auth, Bearer tokens, cookies or REST endpoints
|
|
285
|
+
* are used or assumed.
|
|
286
|
+
*/
|
|
287
|
+
export class ScryptedClient {
|
|
288
|
+
static runtimeFacade = new ScryptedRuntimeFacade();
|
|
289
|
+
runtimeFacade;
|
|
290
|
+
serverUrl;
|
|
291
|
+
token;
|
|
292
|
+
timeoutMs;
|
|
293
|
+
endpointPath;
|
|
294
|
+
constructor(serverUrl, tokenOrOptions, timeoutMs = 6000, runtimeFacade = ScryptedClient.runtimeFacade) {
|
|
295
|
+
this.serverUrl = serverUrl;
|
|
296
|
+
if (typeof tokenOrOptions === "object" && tokenOrOptions !== null) {
|
|
297
|
+
this.token = tokenOrOptions.token;
|
|
298
|
+
this.timeoutMs = tokenOrOptions.timeoutMs ?? timeoutMs;
|
|
299
|
+
this.runtimeFacade = tokenOrOptions.runtimeFacade ?? runtimeFacade;
|
|
300
|
+
this.endpointPath = tokenOrOptions.endpointPath ?? "/api/v1/devices";
|
|
301
|
+
}
|
|
302
|
+
else {
|
|
303
|
+
this.token = tokenOrOptions;
|
|
304
|
+
this.timeoutMs = timeoutMs;
|
|
305
|
+
this.runtimeFacade = runtimeFacade;
|
|
306
|
+
this.endpointPath = "/api/v1/devices";
|
|
307
|
+
}
|
|
308
|
+
}
|
|
309
|
+
/**
|
|
310
|
+
* Normalizes base URL and endpoint path to prevent double slashes.
|
|
311
|
+
*/
|
|
312
|
+
static normalizeUrl(baseUrl, endpointPath = "/api/v1/devices") {
|
|
313
|
+
const raw = (baseUrl || "").trim();
|
|
314
|
+
if (!raw) {
|
|
315
|
+
throw new ScryptedClientError("La URL del servidor no puede estar vacía", "invalid_url");
|
|
316
|
+
}
|
|
317
|
+
const cleanBase = raw.replace(/\/+$/, "");
|
|
318
|
+
const cleanPath = (endpointPath || "").trim().replace(/^\/+/, "");
|
|
319
|
+
return cleanPath ? `${cleanBase}/${cleanPath}` : cleanBase;
|
|
320
|
+
}
|
|
321
|
+
/**
|
|
322
|
+
* Removes sensitive token occurrences from error strings.
|
|
323
|
+
*/
|
|
324
|
+
sanitizeErrorMessage(message) {
|
|
325
|
+
if (!this.token || !this.token.trim())
|
|
326
|
+
return message;
|
|
327
|
+
return message.split(this.token).join("[REDACTED]");
|
|
328
|
+
}
|
|
329
|
+
/**
|
|
330
|
+
* Performs real HTTP discovery against the Scrypted server.
|
|
331
|
+
* - Uses fetch
|
|
332
|
+
* - Normalizes base URL to avoid double slashes
|
|
333
|
+
* - Supports configurable URL, optional token, configurable timeout with AbortController
|
|
334
|
+
* - Sends token strictly via Authorization header
|
|
335
|
+
* - Never logs or includes token in errors
|
|
336
|
+
* - Safely converts network errors, timeout, HTTP 401/403/500, invalid JSON and incomplete responses.
|
|
337
|
+
*/
|
|
338
|
+
async fetchDiscovery(endpointPath) {
|
|
339
|
+
const targetUrl = ScryptedClient.normalizeUrl(this.serverUrl, endpointPath ?? this.endpointPath);
|
|
340
|
+
const headers = {
|
|
341
|
+
Accept: "application/json",
|
|
342
|
+
};
|
|
343
|
+
if (this.token && this.token.trim().length > 0) {
|
|
344
|
+
headers["Authorization"] = this.token.startsWith("Bearer ")
|
|
345
|
+
? this.token.trim()
|
|
346
|
+
: `Bearer ${this.token.trim()}`;
|
|
347
|
+
}
|
|
348
|
+
const controller = new AbortController();
|
|
349
|
+
const timer = setTimeout(() => {
|
|
350
|
+
controller.abort();
|
|
351
|
+
}, this.timeoutMs);
|
|
352
|
+
try {
|
|
353
|
+
const response = await fetch(targetUrl, {
|
|
354
|
+
method: "GET",
|
|
355
|
+
headers,
|
|
356
|
+
signal: controller.signal,
|
|
357
|
+
});
|
|
358
|
+
if (!response.ok) {
|
|
359
|
+
if (response.status === 401) {
|
|
360
|
+
throw new ScryptedClientError("Error de autenticación en Scrypted (HTTP 401). Verifica el token configurado.", "authentication_failed", 401);
|
|
361
|
+
}
|
|
362
|
+
if (response.status === 403) {
|
|
363
|
+
throw new ScryptedClientError("Acceso denegado en Scrypted (HTTP 403). Permisos insuficientes.", "permission_denied", 403);
|
|
364
|
+
}
|
|
365
|
+
if (response.status >= 500) {
|
|
366
|
+
throw new ScryptedClientError(`Error interno del servidor Scrypted (HTTP ${response.status}).`, "server_error", response.status);
|
|
367
|
+
}
|
|
368
|
+
throw new ScryptedClientError(`Error HTTP ${response.status} recibido de Scrypted.`, "unknown", response.status);
|
|
369
|
+
}
|
|
370
|
+
let data;
|
|
371
|
+
try {
|
|
372
|
+
data = await response.json();
|
|
373
|
+
}
|
|
374
|
+
catch {
|
|
375
|
+
throw new ScryptedClientError("Respuesta JSON inválida recibida del servidor Scrypted.", "invalid_json");
|
|
376
|
+
}
|
|
377
|
+
if (!data || typeof data !== "object") {
|
|
378
|
+
throw new ScryptedClientError("Respuesta incompleta del servidor Scrypted: cuerpo de respuesta inválido.", "incomplete_response");
|
|
379
|
+
}
|
|
380
|
+
let rawList;
|
|
381
|
+
if (Array.isArray(data)) {
|
|
382
|
+
rawList = data;
|
|
383
|
+
}
|
|
384
|
+
else if (Array.isArray(data.devices)) {
|
|
385
|
+
rawList = data.devices;
|
|
386
|
+
}
|
|
387
|
+
else if (Array.isArray(data.cameras)) {
|
|
388
|
+
rawList = data.cameras;
|
|
389
|
+
}
|
|
390
|
+
if (!rawList) {
|
|
391
|
+
throw new ScryptedClientError("Respuesta incompleta del servidor Scrypted: falta la propiedad devices o cameras.", "incomplete_response");
|
|
392
|
+
}
|
|
393
|
+
const validDevices = rawList.filter((d) => Boolean(d) &&
|
|
394
|
+
typeof d === "object" &&
|
|
395
|
+
typeof d.id === "string" &&
|
|
396
|
+
d.id.trim().length > 0);
|
|
397
|
+
if (rawList.length > 0 && validDevices.length === 0) {
|
|
398
|
+
throw new ScryptedClientError("Respuesta incompleta del servidor Scrypted: dispositivos sin identificador válido.", "incomplete_response");
|
|
399
|
+
}
|
|
400
|
+
return { devices: validDevices };
|
|
401
|
+
}
|
|
402
|
+
catch (err) {
|
|
403
|
+
if (err instanceof ScryptedClientError) {
|
|
404
|
+
throw err;
|
|
405
|
+
}
|
|
406
|
+
if (err?.name === "AbortError" || controller.signal.aborted) {
|
|
407
|
+
throw new ScryptedClientError(`Tiempo de espera agotado al conectar con Scrypted (${this.timeoutMs}ms).`, "timeout");
|
|
408
|
+
}
|
|
409
|
+
const safeMessage = this.sanitizeErrorMessage(err?.message || "Error de conexión");
|
|
410
|
+
throw new ScryptedClientError(`Error de red al conectar con Scrypted: ${safeMessage}`, "network_error");
|
|
411
|
+
}
|
|
412
|
+
finally {
|
|
413
|
+
clearTimeout(timer);
|
|
414
|
+
}
|
|
415
|
+
}
|
|
416
|
+
/**
|
|
417
|
+
* Discovers cameras through HTTP and ingests them into the runtime facade.
|
|
418
|
+
*/
|
|
419
|
+
async discover(endpointPath) {
|
|
420
|
+
try {
|
|
421
|
+
const payload = await this.fetchDiscovery(endpointPath);
|
|
422
|
+
this.runtimeFacade.setConnectionState(true);
|
|
423
|
+
const snapshot = adaptScryptedClientDiscovery(this.runtimeFacade, payload);
|
|
424
|
+
return snapshot;
|
|
425
|
+
}
|
|
426
|
+
catch (err) {
|
|
427
|
+
this.runtimeFacade.setConnectionState(false);
|
|
428
|
+
throw err;
|
|
429
|
+
}
|
|
430
|
+
}
|
|
431
|
+
/**
|
|
432
|
+
* Returns a runtime connection bound to this client instance.
|
|
433
|
+
*/
|
|
434
|
+
createConnection(endpointPath) {
|
|
435
|
+
return createScryptedRuntimeConnection(() => this.fetchDiscovery(endpointPath));
|
|
436
|
+
}
|
|
437
|
+
/**
|
|
438
|
+
* Returns a fetcher function bound to this client instance.
|
|
439
|
+
*/
|
|
440
|
+
getFetcher(endpointPath) {
|
|
441
|
+
return () => this.fetchDiscovery(endpointPath);
|
|
442
|
+
}
|
|
443
|
+
/**
|
|
444
|
+
* Fetches real stream profiles for a given camera device through active SDK session or HTTP.
|
|
445
|
+
*/
|
|
446
|
+
async fetchStreamProfiles(deviceId) {
|
|
447
|
+
const cleanDeviceId = String(deviceId || "").trim();
|
|
448
|
+
if (!cleanDeviceId)
|
|
449
|
+
return [];
|
|
450
|
+
// 1. If an SDK session is active in ScryptedReconnectManager, use it
|
|
451
|
+
try {
|
|
452
|
+
const { ScryptedReconnectManager } = await import("./scrypted-reconnect-manager.js");
|
|
453
|
+
const reconnectMgr = ScryptedReconnectManager.getInstance();
|
|
454
|
+
const activeSession = reconnectMgr?.activeSession;
|
|
455
|
+
if (activeSession?.sdk) {
|
|
456
|
+
const sdkProfiles = await ScryptedClient.fetchStreamProfiles(activeSession, cleanDeviceId);
|
|
457
|
+
if (sdkProfiles.length > 0)
|
|
458
|
+
return sdkProfiles;
|
|
459
|
+
}
|
|
460
|
+
}
|
|
461
|
+
catch {
|
|
462
|
+
// Fallback to HTTP
|
|
463
|
+
}
|
|
464
|
+
// 2. Query Scrypted HTTP API
|
|
465
|
+
const controller = new AbortController();
|
|
466
|
+
const timer = setTimeout(() => controller.abort(), this.timeoutMs);
|
|
467
|
+
const headers = { Accept: "application/json" };
|
|
468
|
+
if (this.token && this.token.trim().length > 0) {
|
|
469
|
+
headers["Authorization"] = this.token.startsWith("Bearer ")
|
|
470
|
+
? this.token.trim()
|
|
471
|
+
: `Bearer ${this.token.trim()}`;
|
|
472
|
+
}
|
|
473
|
+
const profilesEndpoint = `/api/v1/devices/${encodeURIComponent(cleanDeviceId)}/getVideoStreamOptions`;
|
|
474
|
+
const targetUrl = ScryptedClient.normalizeUrl(this.serverUrl, profilesEndpoint);
|
|
475
|
+
const now = new Date().toISOString();
|
|
476
|
+
try {
|
|
477
|
+
const response = await fetch(targetUrl, {
|
|
478
|
+
method: "GET",
|
|
479
|
+
headers,
|
|
480
|
+
signal: controller.signal,
|
|
481
|
+
});
|
|
482
|
+
if (response.ok) {
|
|
483
|
+
let streamOptions = null;
|
|
484
|
+
try {
|
|
485
|
+
streamOptions = await response.json();
|
|
486
|
+
}
|
|
487
|
+
catch {
|
|
488
|
+
streamOptions = null;
|
|
489
|
+
}
|
|
490
|
+
if (Array.isArray(streamOptions) && streamOptions.length > 0) {
|
|
491
|
+
const profiles = [];
|
|
492
|
+
for (const opt of streamOptions) {
|
|
493
|
+
if (!opt)
|
|
494
|
+
continue;
|
|
495
|
+
let directUrl = typeof opt.url === "string" && opt.url.trim().length > 0
|
|
496
|
+
? opt.url.trim()
|
|
497
|
+
: undefined;
|
|
498
|
+
if (directUrl && isInventedRtspUrl(directUrl, cleanDeviceId)) {
|
|
499
|
+
directUrl = undefined;
|
|
500
|
+
}
|
|
501
|
+
profiles.push({
|
|
502
|
+
id: String(opt.id || opt.name || `stream_${profiles.length}`),
|
|
503
|
+
name: String(opt.name || opt.id || `Stream ${profiles.length + 1}`),
|
|
504
|
+
container: opt.container,
|
|
505
|
+
videoCodec: opt.video?.codec,
|
|
506
|
+
audioCodec: opt.audio?.codec,
|
|
507
|
+
resolution: opt.video?.width && opt.video?.height
|
|
508
|
+
? { width: opt.video.width, height: opt.video.height }
|
|
509
|
+
: undefined,
|
|
510
|
+
fps: opt.video?.fps,
|
|
511
|
+
bitrateKbps: opt.video?.bitrate
|
|
512
|
+
? Math.round(opt.video.bitrate / 1000)
|
|
513
|
+
: undefined,
|
|
514
|
+
hasAudio: opt.audio !== undefined && opt.audio !== null
|
|
515
|
+
? Boolean(opt.audio)
|
|
516
|
+
: true,
|
|
517
|
+
directUrl,
|
|
518
|
+
discoveredAt: now,
|
|
519
|
+
validationStatus: directUrl ? "not_checked" : "unsupported",
|
|
520
|
+
});
|
|
521
|
+
}
|
|
522
|
+
if (profiles.length > 0)
|
|
523
|
+
return profiles;
|
|
524
|
+
}
|
|
525
|
+
}
|
|
526
|
+
}
|
|
527
|
+
catch (err) {
|
|
528
|
+
const safeMsg = this.sanitizeErrorMessage(err?.message || "Error al obtener perfiles HTTP");
|
|
529
|
+
console.warn(`[Scrypted][${cleanDeviceId}] Error al obtener perfiles de stream: ${safeMsg}`);
|
|
530
|
+
}
|
|
531
|
+
finally {
|
|
532
|
+
clearTimeout(timer);
|
|
533
|
+
}
|
|
534
|
+
return [];
|
|
535
|
+
}
|
|
536
|
+
/**
|
|
537
|
+
* Instance helper for backward compatibility in existing code.
|
|
538
|
+
*/
|
|
539
|
+
async listCameras(session) {
|
|
540
|
+
if (session) {
|
|
541
|
+
return ScryptedClient.listCameras.call(this, session);
|
|
542
|
+
}
|
|
543
|
+
const snapshot = await this.discover();
|
|
544
|
+
const rawDevices = snapshot?.cameras ?? [];
|
|
545
|
+
const cameras = rawDevices.map((item) => mapDeviceToCameraRecord({
|
|
546
|
+
id: item.normalized.id,
|
|
547
|
+
name: item.normalized.name,
|
|
548
|
+
manufacturer: item.normalized.brand !== "Marca no identificada"
|
|
549
|
+
? item.normalized.brand
|
|
550
|
+
: undefined,
|
|
551
|
+
model: item.normalized.model ?? undefined,
|
|
552
|
+
directUrl: item.normalized.directUrl,
|
|
553
|
+
streamReference: item.normalized.streamReference,
|
|
554
|
+
snapshotReference: item.normalized.snapshotReference,
|
|
555
|
+
profiles: item.normalized.profiles,
|
|
556
|
+
}, this.serverUrl, item.normalized.id));
|
|
557
|
+
for (const camera of cameras) {
|
|
558
|
+
try {
|
|
559
|
+
if (!camera.source.streamReference?.directUrl) {
|
|
560
|
+
const profiles = await this.fetchStreamProfiles(camera.cameraId);
|
|
561
|
+
if (profiles.length > 0) {
|
|
562
|
+
camera.source.profiles = profiles;
|
|
563
|
+
camera.source.selectedProfileId = profiles[0].id;
|
|
564
|
+
const primary = profiles.find((p) => p.directUrl) || profiles[0];
|
|
565
|
+
if (primary?.directUrl) {
|
|
566
|
+
camera.source.streamReference = {
|
|
567
|
+
protocol: "rtsp",
|
|
568
|
+
directUrl: primary.directUrl,
|
|
569
|
+
validationStatus: primary.validationStatus,
|
|
570
|
+
};
|
|
571
|
+
camera.source.streamValidationStatus = primary.validationStatus;
|
|
572
|
+
}
|
|
573
|
+
}
|
|
574
|
+
}
|
|
575
|
+
}
|
|
576
|
+
catch (profileErr) {
|
|
577
|
+
console.warn(`[Scrypted][${camera.cameraId}] Error al enriquecer perfiles: ${this.sanitizeErrorMessage(profileErr?.message || String(profileErr))}`);
|
|
578
|
+
}
|
|
579
|
+
}
|
|
580
|
+
return cameras;
|
|
581
|
+
}
|
|
582
|
+
/**
|
|
583
|
+
* Instance helper for backward compatibility in existing code.
|
|
584
|
+
*/
|
|
585
|
+
async testConnection() {
|
|
586
|
+
if (this.token) {
|
|
587
|
+
const start = Date.now();
|
|
588
|
+
try {
|
|
589
|
+
await this.fetchDiscovery();
|
|
590
|
+
return {
|
|
591
|
+
ok: true,
|
|
592
|
+
message: "Conexión correcta con Scrypted mediante token API.",
|
|
593
|
+
authenticationMode: "api_token",
|
|
594
|
+
latencyMs: Date.now() - start,
|
|
595
|
+
};
|
|
596
|
+
}
|
|
597
|
+
catch (err) {
|
|
598
|
+
if (err instanceof ScryptedClientError) {
|
|
599
|
+
return {
|
|
600
|
+
ok: false,
|
|
601
|
+
errorCode: err.code,
|
|
602
|
+
message: this.sanitizeErrorMessage(err.message),
|
|
603
|
+
latencyMs: Date.now() - start,
|
|
604
|
+
};
|
|
605
|
+
}
|
|
606
|
+
return {
|
|
607
|
+
ok: false,
|
|
608
|
+
errorCode: "unknown",
|
|
609
|
+
message: "Error al conectar con Scrypted.",
|
|
610
|
+
latencyMs: Date.now() - start,
|
|
611
|
+
};
|
|
612
|
+
}
|
|
613
|
+
}
|
|
614
|
+
return ScryptedClient.testConnection(this.serverUrl, {
|
|
615
|
+
username: "admin",
|
|
616
|
+
authenticationMode: "username_password",
|
|
617
|
+
}, undefined, false);
|
|
618
|
+
}
|
|
619
|
+
/**
|
|
620
|
+
* Validates and normalizes the server URL.
|
|
621
|
+
* Rejects non-HTTP/HTTPS, malformed URLs and removes trailing slashes.
|
|
622
|
+
*/
|
|
623
|
+
static validateServerUrl(rawUrl) {
|
|
624
|
+
if (!rawUrl || typeof rawUrl !== "string" || rawUrl.trim().length === 0) {
|
|
625
|
+
return {
|
|
626
|
+
valid: false,
|
|
627
|
+
error: "La URL del servidor no puede estar vacía",
|
|
628
|
+
};
|
|
629
|
+
}
|
|
630
|
+
try {
|
|
631
|
+
const parsed = new URL(rawUrl.trim());
|
|
632
|
+
if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
|
|
633
|
+
return {
|
|
634
|
+
valid: false,
|
|
635
|
+
error: "Protocolo inválido (debe ser http:// o https://)",
|
|
636
|
+
};
|
|
637
|
+
}
|
|
638
|
+
// Strip credentials from URL to prevent SSRF via embedded auth
|
|
639
|
+
parsed.username = "";
|
|
640
|
+
parsed.password = "";
|
|
641
|
+
// Remove trailing slash for consistency
|
|
642
|
+
const normalized = parsed.toString().replace(/\/+$/, "");
|
|
643
|
+
return { valid: true, normalizedUrl: normalized, url: parsed };
|
|
644
|
+
}
|
|
645
|
+
catch {
|
|
646
|
+
return { valid: false, error: "Formato de URL inválido" };
|
|
647
|
+
}
|
|
648
|
+
}
|
|
649
|
+
/**
|
|
650
|
+
* Tests connection using the official @scrypted/client SDK.
|
|
651
|
+
* Uses loginScryptedClient internally (POST /login to Scrypted server).
|
|
652
|
+
* Does NOT persist anything on failure.
|
|
653
|
+
*/
|
|
654
|
+
static async testConnection(serverUrl, credentials, password, allowSelfSignedCertificate = false) {
|
|
655
|
+
const urlCheck = ScryptedClient.validateServerUrl(serverUrl);
|
|
656
|
+
if (!urlCheck.valid || !urlCheck.normalizedUrl) {
|
|
657
|
+
return {
|
|
658
|
+
ok: false,
|
|
659
|
+
errorCode: "invalid_url",
|
|
660
|
+
message: "La URL de Scrypted no es válida.",
|
|
661
|
+
};
|
|
662
|
+
}
|
|
663
|
+
const username = credentials.username;
|
|
664
|
+
if (!username || !password) {
|
|
665
|
+
return {
|
|
666
|
+
ok: false,
|
|
667
|
+
errorCode: "authentication_failed",
|
|
668
|
+
message: "No se pudo iniciar sesión en Scrypted. Verifica usuario y contraseña.",
|
|
669
|
+
};
|
|
670
|
+
}
|
|
671
|
+
const start = Date.now();
|
|
672
|
+
try {
|
|
673
|
+
const scryptedModule = await import("@scrypted/client");
|
|
674
|
+
const loginScryptedClient = scryptedModule.loginScryptedClient;
|
|
675
|
+
if (typeof loginScryptedClient !== "function") {
|
|
676
|
+
return {
|
|
677
|
+
ok: false,
|
|
678
|
+
errorCode: "unsupported_api",
|
|
679
|
+
message: "Esta versión de Scrypted no ofrece las interfaces requeridas por la integración.",
|
|
680
|
+
};
|
|
681
|
+
}
|
|
682
|
+
const loginResult = await loginScryptedClient({
|
|
683
|
+
baseUrl: urlCheck.normalizedUrl,
|
|
684
|
+
username,
|
|
685
|
+
password,
|
|
686
|
+
});
|
|
687
|
+
if (loginResult?.error) {
|
|
688
|
+
return {
|
|
689
|
+
ok: false,
|
|
690
|
+
errorCode: "authentication_failed",
|
|
691
|
+
message: "No se pudo iniciar sesión en Scrypted. Verifica usuario y contraseña.",
|
|
692
|
+
latencyMs: Date.now() - start,
|
|
693
|
+
};
|
|
694
|
+
}
|
|
695
|
+
const latencyMs = Date.now() - start;
|
|
696
|
+
return {
|
|
697
|
+
ok: true,
|
|
698
|
+
message: "Conexión correcta. Se autenticó mediante: usuario y contraseña",
|
|
699
|
+
authenticationMode: "username_password",
|
|
700
|
+
latencyMs,
|
|
701
|
+
serverId: loginResult?.serverId,
|
|
702
|
+
};
|
|
703
|
+
}
|
|
704
|
+
catch (err) {
|
|
705
|
+
const latencyMs = Date.now() - start;
|
|
706
|
+
return ScryptedClient.classifyError(err, latencyMs);
|
|
707
|
+
}
|
|
708
|
+
}
|
|
709
|
+
/**
|
|
710
|
+
* Establishes a full SDK session via connectScryptedClient.
|
|
711
|
+
* The returned session object must stay in memory only.
|
|
712
|
+
* Call disconnect(session) when done.
|
|
713
|
+
*/
|
|
714
|
+
static async connect(serverUrl, credentials, password) {
|
|
715
|
+
const urlCheck = ScryptedClient.validateServerUrl(serverUrl);
|
|
716
|
+
if (!urlCheck.valid || !urlCheck.normalizedUrl) {
|
|
717
|
+
throw new Error(`invalid_url: ${urlCheck.error}`);
|
|
718
|
+
}
|
|
719
|
+
const username = credentials.username;
|
|
720
|
+
if (!username || !password) {
|
|
721
|
+
throw new Error("authentication_failed: username and password are required");
|
|
722
|
+
}
|
|
723
|
+
const scryptedModule = await import("@scrypted/client");
|
|
724
|
+
const connectScryptedClient = scryptedModule.connectScryptedClient;
|
|
725
|
+
if (typeof connectScryptedClient !== "function") {
|
|
726
|
+
throw new Error("unsupported_api: connectScryptedClient function not found in @scrypted/client");
|
|
727
|
+
}
|
|
728
|
+
const sdk = await connectScryptedClient({
|
|
729
|
+
baseUrl: urlCheck.normalizedUrl,
|
|
730
|
+
pluginId: "@scrypted/core",
|
|
731
|
+
username,
|
|
732
|
+
password,
|
|
733
|
+
});
|
|
734
|
+
return {
|
|
735
|
+
sdk,
|
|
736
|
+
connectedAt: new Date().toISOString(),
|
|
737
|
+
serverUrl: urlCheck.normalizedUrl,
|
|
738
|
+
username,
|
|
739
|
+
};
|
|
740
|
+
}
|
|
741
|
+
/**
|
|
742
|
+
* Enumerates all camera devices from the Scrypted server via systemManager.
|
|
743
|
+
* Only reads real device data — no capabilities are hardcoded.
|
|
744
|
+
*/
|
|
745
|
+
static async listCameras(session) {
|
|
746
|
+
const systemManager = session.sdk?.systemManager;
|
|
747
|
+
if (!systemManager) {
|
|
748
|
+
throw new Error("unsupported_api: systemManager not available");
|
|
749
|
+
}
|
|
750
|
+
let rawState = {};
|
|
751
|
+
try {
|
|
752
|
+
if (typeof systemManager.getSystemState === "function") {
|
|
753
|
+
rawState = (await systemManager.getSystemState()) || {};
|
|
754
|
+
}
|
|
755
|
+
}
|
|
756
|
+
catch (err) {
|
|
757
|
+
console.warn("[Scrypted] Error calling getSystemState():", err);
|
|
758
|
+
rawState = {};
|
|
759
|
+
}
|
|
760
|
+
const response = {
|
|
761
|
+
devices: rawState?.devices ??
|
|
762
|
+
(Array.isArray(rawState) ? rawState : undefined) ??
|
|
763
|
+
systemManager?.devices ??
|
|
764
|
+
session.sdk?.devices ??
|
|
765
|
+
session?.devices,
|
|
766
|
+
cameras: rawState?.cameras ??
|
|
767
|
+
systemManager?.cameras ??
|
|
768
|
+
session.sdk?.cameras ??
|
|
769
|
+
session?.cameras,
|
|
770
|
+
};
|
|
771
|
+
const cameras = [];
|
|
772
|
+
const seenIds = new Set();
|
|
773
|
+
if (this && this.runtimeFacade) {
|
|
774
|
+
const snapshot = adaptScryptedClientDiscovery(this.runtimeFacade, response);
|
|
775
|
+
if (snapshot.cameras && snapshot.cameras.length > 0) {
|
|
776
|
+
const rawList = Array.isArray(response.devices)
|
|
777
|
+
? response.devices
|
|
778
|
+
: Array.isArray(response.cameras)
|
|
779
|
+
? response.cameras
|
|
780
|
+
: [];
|
|
781
|
+
for (const item of snapshot.cameras) {
|
|
782
|
+
const id = item.normalized.id;
|
|
783
|
+
if (!seenIds.has(id)) {
|
|
784
|
+
seenIds.add(id);
|
|
785
|
+
const rawDev = rawList.find((d) => d && String(d.id) === id) ?? {};
|
|
786
|
+
cameras.push(mapDeviceToCameraRecord({
|
|
787
|
+
...rawDev,
|
|
788
|
+
id,
|
|
789
|
+
name: item.normalized.name,
|
|
790
|
+
manufacturer: item.normalized.brand !== "Marca no identificada"
|
|
791
|
+
? item.normalized.brand
|
|
792
|
+
: rawDev?.manufacturer,
|
|
793
|
+
model: item.normalized.model ?? rawDev?.model,
|
|
794
|
+
}, session.serverUrl, id));
|
|
795
|
+
}
|
|
796
|
+
}
|
|
797
|
+
}
|
|
798
|
+
}
|
|
799
|
+
const deviceIds = Object.keys(rawState);
|
|
800
|
+
if (cameras.length === 0) {
|
|
801
|
+
for (const id of deviceIds) {
|
|
802
|
+
try {
|
|
803
|
+
let dev = null;
|
|
804
|
+
if (typeof systemManager.getDeviceById === "function") {
|
|
805
|
+
try {
|
|
806
|
+
dev = systemManager.getDeviceById(id);
|
|
807
|
+
}
|
|
808
|
+
catch {
|
|
809
|
+
dev = null;
|
|
810
|
+
}
|
|
811
|
+
}
|
|
812
|
+
const stateDev = rawState[id];
|
|
813
|
+
// Merge properties from proxy and raw state to guarantee all fields are accessible
|
|
814
|
+
const combined = {
|
|
815
|
+
id,
|
|
816
|
+
name: dev?.name ?? unwrapScryptedValue(stateDev?.name),
|
|
817
|
+
type: dev?.type ?? unwrapScryptedValue(stateDev?.type),
|
|
818
|
+
providedType: dev?.providedType ?? unwrapScryptedValue(stateDev?.providedType),
|
|
819
|
+
interfaces: dev?.interfaces ?? unwrapScryptedValue(stateDev?.interfaces),
|
|
820
|
+
providedInterfaces: dev?.providedInterfaces ??
|
|
821
|
+
unwrapScryptedValue(stateDev?.providedInterfaces),
|
|
822
|
+
info: dev?.info ?? unwrapScryptedValue(stateDev?.info),
|
|
823
|
+
manufacturer: dev?.manufacturer ?? unwrapScryptedValue(stateDev?.manufacturer),
|
|
824
|
+
model: dev?.model ?? unwrapScryptedValue(stateDev?.model),
|
|
825
|
+
serialNumber: dev?.serialNumber ?? unwrapScryptedValue(stateDev?.serialNumber),
|
|
826
|
+
};
|
|
827
|
+
if (isCameraDevice(combined) && !seenIds.has(id)) {
|
|
828
|
+
seenIds.add(id);
|
|
829
|
+
cameras.push(mapDeviceToCameraRecord(combined, session.serverUrl, id));
|
|
830
|
+
}
|
|
831
|
+
}
|
|
832
|
+
catch {
|
|
833
|
+
// Skip device that cannot be mapped
|
|
834
|
+
}
|
|
835
|
+
}
|
|
836
|
+
// Fallback: If deviceIds was empty or an array of objects
|
|
837
|
+
if (cameras.length === 0) {
|
|
838
|
+
let fallbackList = [];
|
|
839
|
+
if (Array.isArray(rawState)) {
|
|
840
|
+
fallbackList = rawState;
|
|
841
|
+
}
|
|
842
|
+
else if (typeof systemManager.getDeviceIds === "function") {
|
|
843
|
+
try {
|
|
844
|
+
const ids = systemManager.getDeviceIds();
|
|
845
|
+
fallbackList = ids.map((id) => systemManager.getDeviceById(id));
|
|
846
|
+
}
|
|
847
|
+
catch { }
|
|
848
|
+
}
|
|
849
|
+
else if (Object.keys(rawState).length > 0) {
|
|
850
|
+
fallbackList = Object.values(rawState);
|
|
851
|
+
}
|
|
852
|
+
for (const dev of fallbackList) {
|
|
853
|
+
if (!dev)
|
|
854
|
+
continue;
|
|
855
|
+
try {
|
|
856
|
+
const id = String(unwrapScryptedValue(dev.id) || "");
|
|
857
|
+
if (isCameraDevice(dev) && id && !seenIds.has(id)) {
|
|
858
|
+
seenIds.add(id);
|
|
859
|
+
cameras.push(mapDeviceToCameraRecord(dev, session.serverUrl, id));
|
|
860
|
+
}
|
|
861
|
+
}
|
|
862
|
+
catch { }
|
|
863
|
+
}
|
|
864
|
+
}
|
|
865
|
+
}
|
|
866
|
+
const totalCount = Array.isArray(response.devices)
|
|
867
|
+
? response.devices.length
|
|
868
|
+
: Array.isArray(response.cameras)
|
|
869
|
+
? response.cameras.length
|
|
870
|
+
: deviceIds.length;
|
|
871
|
+
console.log(`[Scrypted] Discovered ${totalCount} total devices in systemState, identified ${cameras.length} cameras.`);
|
|
872
|
+
// Enrich cameras with real stream profiles from Scrypted SDK
|
|
873
|
+
for (const camera of cameras) {
|
|
874
|
+
try {
|
|
875
|
+
const profiles = await ScryptedClient.fetchStreamProfiles(session, camera.cameraId);
|
|
876
|
+
if (profiles.length > 0) {
|
|
877
|
+
camera.source.profiles = profiles;
|
|
878
|
+
camera.source.selectedProfileId = profiles[0].id;
|
|
879
|
+
const primary = profiles.find((p) => p.directUrl) || profiles[0];
|
|
880
|
+
if (primary?.directUrl) {
|
|
881
|
+
camera.source.streamReference = {
|
|
882
|
+
protocol: "rtsp",
|
|
883
|
+
directUrl: primary.directUrl,
|
|
884
|
+
validationStatus: primary.validationStatus,
|
|
885
|
+
};
|
|
886
|
+
camera.source.streamValidationStatus = primary.validationStatus;
|
|
887
|
+
}
|
|
888
|
+
}
|
|
889
|
+
}
|
|
890
|
+
catch (profileErr) {
|
|
891
|
+
console.warn(`[Scrypted] Failed to fetch stream profiles for ${camera.cameraId}:`, profileErr);
|
|
892
|
+
}
|
|
893
|
+
}
|
|
894
|
+
return cameras;
|
|
895
|
+
}
|
|
896
|
+
/**
|
|
897
|
+
* Helper that converts a MediaObject to a URI string using mediaManager.
|
|
898
|
+
* Tries convertMediaObjectToUrl, then convertMediaObjectToLocalUrl,
|
|
899
|
+
* then convertMediaObjectToInsecureLocalUrl for maximum compatibility.
|
|
900
|
+
*/
|
|
901
|
+
static async resolveMediaObjectUri(mediaManager, mo) {
|
|
902
|
+
if (!mediaManager || !mo)
|
|
903
|
+
return undefined;
|
|
904
|
+
const methods = [
|
|
905
|
+
"convertMediaObjectToLocalUrl",
|
|
906
|
+
"convertMediaObjectToInsecureLocalUrl",
|
|
907
|
+
"convertMediaObjectToUrl",
|
|
908
|
+
];
|
|
909
|
+
for (const method of methods) {
|
|
910
|
+
if (typeof mediaManager[method] === "function") {
|
|
911
|
+
try {
|
|
912
|
+
const resolved = await mediaManager[method](mo, "text/x-uri");
|
|
913
|
+
if (typeof resolved === "string" && resolved.trim().length > 0) {
|
|
914
|
+
return resolved.trim();
|
|
915
|
+
}
|
|
916
|
+
}
|
|
917
|
+
catch {
|
|
918
|
+
// Try next converter
|
|
919
|
+
}
|
|
920
|
+
}
|
|
921
|
+
}
|
|
922
|
+
return undefined;
|
|
923
|
+
}
|
|
924
|
+
/**
|
|
925
|
+
* Fetches real stream profiles for a given camera device using the official Scrypted SDK.
|
|
926
|
+
* Calls device.getVideoStreamOptions() and optionally resolves direct stream URLs
|
|
927
|
+
* using mediaManager converters.
|
|
928
|
+
*
|
|
929
|
+
* NEVER invents an RTSP URL. Returns [] if no stream options are available.
|
|
930
|
+
*/
|
|
931
|
+
static async fetchStreamProfiles(session, deviceId) {
|
|
932
|
+
const systemManager = session.sdk?.systemManager;
|
|
933
|
+
const mediaManager = session.sdk?.mediaManager;
|
|
934
|
+
if (!systemManager)
|
|
935
|
+
return [];
|
|
936
|
+
let dev = null;
|
|
937
|
+
try {
|
|
938
|
+
if (typeof systemManager.getDeviceById === "function") {
|
|
939
|
+
dev = systemManager.getDeviceById(deviceId);
|
|
940
|
+
}
|
|
941
|
+
}
|
|
942
|
+
catch (err) {
|
|
943
|
+
console.warn(`[Scrypted] getDeviceById(${deviceId}) failed:`, err);
|
|
944
|
+
return [];
|
|
945
|
+
}
|
|
946
|
+
if (!dev)
|
|
947
|
+
return [];
|
|
948
|
+
const profiles = [];
|
|
949
|
+
const now = new Date().toISOString();
|
|
950
|
+
// 1. Check if device supports getVideoStreamOptions()
|
|
951
|
+
if (typeof dev.getVideoStreamOptions === "function") {
|
|
952
|
+
try {
|
|
953
|
+
const streamOptions = (await dev.getVideoStreamOptions()) || [];
|
|
954
|
+
if (Array.isArray(streamOptions)) {
|
|
955
|
+
for (const opt of streamOptions) {
|
|
956
|
+
if (!opt)
|
|
957
|
+
continue;
|
|
958
|
+
const profileId = String(opt.id || opt.name || `stream_${profiles.length}`);
|
|
959
|
+
const profileName = String(opt.name || opt.id || `Stream ${profiles.length + 1}`);
|
|
960
|
+
let directUrl = undefined;
|
|
961
|
+
// If opt.url exists (direct RTSP from Rebroadcast plugin)
|
|
962
|
+
if (typeof opt.url === "string" && opt.url.trim().length > 0) {
|
|
963
|
+
directUrl = opt.url.trim();
|
|
964
|
+
}
|
|
965
|
+
else if (typeof dev.getVideoStream === "function" &&
|
|
966
|
+
mediaManager) {
|
|
967
|
+
try {
|
|
968
|
+
let mo = null;
|
|
969
|
+
try {
|
|
970
|
+
mo = await dev.getVideoStream({ id: opt.id });
|
|
971
|
+
}
|
|
972
|
+
catch {
|
|
973
|
+
try {
|
|
974
|
+
mo = await dev.getVideoStream({ id: opt.id, destination: "local" });
|
|
975
|
+
}
|
|
976
|
+
catch { }
|
|
977
|
+
}
|
|
978
|
+
if (mo) {
|
|
979
|
+
const resolvedUrl = await ScryptedClient.resolveMediaObjectUri(mediaManager, mo);
|
|
980
|
+
if (resolvedUrl) {
|
|
981
|
+
directUrl = resolvedUrl;
|
|
982
|
+
}
|
|
983
|
+
}
|
|
984
|
+
}
|
|
985
|
+
catch {
|
|
986
|
+
// Not all profiles can be converted to static URL directly; that's normal
|
|
987
|
+
}
|
|
988
|
+
}
|
|
989
|
+
// Safety check: NEVER accept an invented URL (path is /<cameraId>)
|
|
990
|
+
if (directUrl && isInventedRtspUrl(directUrl, deviceId)) {
|
|
991
|
+
directUrl = undefined;
|
|
992
|
+
}
|
|
993
|
+
profiles.push({
|
|
994
|
+
id: profileId,
|
|
995
|
+
name: profileName,
|
|
996
|
+
container: opt.container,
|
|
997
|
+
videoCodec: opt.video?.codec,
|
|
998
|
+
audioCodec: opt.audio?.codec,
|
|
999
|
+
resolution: opt.video?.width && opt.video?.height
|
|
1000
|
+
? { width: opt.video.width, height: opt.video.height }
|
|
1001
|
+
: undefined,
|
|
1002
|
+
fps: opt.video?.fps,
|
|
1003
|
+
bitrateKbps: opt.video?.bitrate
|
|
1004
|
+
? Math.round(opt.video.bitrate / 1000)
|
|
1005
|
+
: undefined,
|
|
1006
|
+
hasAudio: opt.audio !== undefined && opt.audio !== null
|
|
1007
|
+
? Boolean(opt.audio)
|
|
1008
|
+
: true,
|
|
1009
|
+
directUrl,
|
|
1010
|
+
discoveredAt: now,
|
|
1011
|
+
validationStatus: directUrl ? "not_checked" : "unsupported",
|
|
1012
|
+
});
|
|
1013
|
+
}
|
|
1014
|
+
}
|
|
1015
|
+
}
|
|
1016
|
+
catch (optErr) {
|
|
1017
|
+
console.warn(`[Scrypted][${deviceId}] Error calling getVideoStreamOptions:`, optErr);
|
|
1018
|
+
}
|
|
1019
|
+
}
|
|
1020
|
+
// 2. If no profiles returned from getVideoStreamOptions but device has getVideoStream,
|
|
1021
|
+
// attempt default getVideoStream()
|
|
1022
|
+
if (profiles.length === 0 &&
|
|
1023
|
+
typeof dev.getVideoStream === "function" &&
|
|
1024
|
+
mediaManager) {
|
|
1025
|
+
try {
|
|
1026
|
+
let mo = null;
|
|
1027
|
+
try {
|
|
1028
|
+
mo = await dev.getVideoStream();
|
|
1029
|
+
}
|
|
1030
|
+
catch {
|
|
1031
|
+
try {
|
|
1032
|
+
mo = await dev.getVideoStream({ destination: "local" });
|
|
1033
|
+
}
|
|
1034
|
+
catch { }
|
|
1035
|
+
}
|
|
1036
|
+
if (mo) {
|
|
1037
|
+
const resolvedUrl = await ScryptedClient.resolveMediaObjectUri(mediaManager, mo);
|
|
1038
|
+
if (resolvedUrl &&
|
|
1039
|
+
!isInventedRtspUrl(resolvedUrl, deviceId)) {
|
|
1040
|
+
profiles.push({
|
|
1041
|
+
id: "default",
|
|
1042
|
+
name: "Default Stream",
|
|
1043
|
+
directUrl: resolvedUrl,
|
|
1044
|
+
discoveredAt: now,
|
|
1045
|
+
validationStatus: "not_checked",
|
|
1046
|
+
});
|
|
1047
|
+
}
|
|
1048
|
+
}
|
|
1049
|
+
}
|
|
1050
|
+
catch {
|
|
1051
|
+
// Fallback also failed — return empty profiles
|
|
1052
|
+
}
|
|
1053
|
+
}
|
|
1054
|
+
return profiles;
|
|
1055
|
+
}
|
|
1056
|
+
/**
|
|
1057
|
+
* Disconnects an active SDK session.
|
|
1058
|
+
*/
|
|
1059
|
+
static async disconnect(session) {
|
|
1060
|
+
try {
|
|
1061
|
+
session.sdk?.disconnect?.();
|
|
1062
|
+
}
|
|
1063
|
+
catch {
|
|
1064
|
+
// Best effort
|
|
1065
|
+
}
|
|
1066
|
+
}
|
|
1067
|
+
/**
|
|
1068
|
+
* Classifies SDK errors into typed ScryptedErrorCode categories.
|
|
1069
|
+
* Never includes password, token, URL credentials or stack traces in messages.
|
|
1070
|
+
*/
|
|
1071
|
+
static classifyError(err, latencyMs) {
|
|
1072
|
+
const msg = String(err?.message || err || "").toLowerCase();
|
|
1073
|
+
const code = String(err?.code || "").toLowerCase();
|
|
1074
|
+
if (code === "econnrefused" ||
|
|
1075
|
+
code === "enotfound" ||
|
|
1076
|
+
code === "ehostunreach" ||
|
|
1077
|
+
code === "econnreset" ||
|
|
1078
|
+
msg.includes("econnrefused") ||
|
|
1079
|
+
msg.includes("fetch failed") ||
|
|
1080
|
+
msg.includes("network") ||
|
|
1081
|
+
msg.includes("timeout") ||
|
|
1082
|
+
msg.includes("abort")) {
|
|
1083
|
+
return {
|
|
1084
|
+
ok: false,
|
|
1085
|
+
errorCode: "network_error",
|
|
1086
|
+
message: "No se puede conectar al servidor Scrypted. Revisa IP, puerto, red y firewall.",
|
|
1087
|
+
latencyMs,
|
|
1088
|
+
};
|
|
1089
|
+
}
|
|
1090
|
+
if (msg.includes("cert") ||
|
|
1091
|
+
msg.includes("ssl") ||
|
|
1092
|
+
msg.includes("tls") ||
|
|
1093
|
+
msg.includes("self signed") ||
|
|
1094
|
+
msg.includes("certificate") ||
|
|
1095
|
+
code === "depth_zero_self_signed_cert" ||
|
|
1096
|
+
code === "self_signed_cert_in_chain" ||
|
|
1097
|
+
code === "unable_to_verify_leaf_signature") {
|
|
1098
|
+
return {
|
|
1099
|
+
ok: false,
|
|
1100
|
+
errorCode: "tls_error",
|
|
1101
|
+
message: "El certificado HTTPS no fue aceptado. Comprueba el certificado o habilita explícitamente certificados autofirmados si confías en el servidor.",
|
|
1102
|
+
latencyMs,
|
|
1103
|
+
};
|
|
1104
|
+
}
|
|
1105
|
+
if (msg.includes("401") ||
|
|
1106
|
+
msg.includes("403") ||
|
|
1107
|
+
msg.includes("unauthorized") ||
|
|
1108
|
+
msg.includes("forbidden") ||
|
|
1109
|
+
msg.includes("status 401") ||
|
|
1110
|
+
msg.includes("status 403") ||
|
|
1111
|
+
msg.includes("password") ||
|
|
1112
|
+
msg.includes("credentials") ||
|
|
1113
|
+
msg.includes("error")) {
|
|
1114
|
+
return {
|
|
1115
|
+
ok: false,
|
|
1116
|
+
errorCode: "authentication_failed",
|
|
1117
|
+
message: "No se pudo iniciar sesión en Scrypted. Verifica usuario y contraseña.",
|
|
1118
|
+
latencyMs,
|
|
1119
|
+
};
|
|
1120
|
+
}
|
|
1121
|
+
return {
|
|
1122
|
+
ok: false,
|
|
1123
|
+
errorCode: "unknown",
|
|
1124
|
+
message: "Error desconocido al conectar con Scrypted. Revisa los logs del servidor.",
|
|
1125
|
+
latencyMs,
|
|
1126
|
+
};
|
|
1127
|
+
}
|
|
1128
|
+
/**
|
|
1129
|
+
* Tests whether an RTSP stream endpoint is accessible via TCP probe.
|
|
1130
|
+
* A successful probe does NOT guarantee stream availability.
|
|
1131
|
+
*/
|
|
1132
|
+
static async probeRtspPort(host, port = 8554, timeoutMs = 2500) {
|
|
1133
|
+
return new Promise((resolve) => {
|
|
1134
|
+
const socket = new net.Socket();
|
|
1135
|
+
let settled = false;
|
|
1136
|
+
socket.setTimeout(timeoutMs);
|
|
1137
|
+
socket.on("connect", () => {
|
|
1138
|
+
if (!settled) {
|
|
1139
|
+
settled = true;
|
|
1140
|
+
socket.destroy();
|
|
1141
|
+
resolve(true);
|
|
1142
|
+
}
|
|
1143
|
+
});
|
|
1144
|
+
socket.on("timeout", () => {
|
|
1145
|
+
if (!settled) {
|
|
1146
|
+
settled = true;
|
|
1147
|
+
socket.destroy();
|
|
1148
|
+
resolve(false);
|
|
1149
|
+
}
|
|
1150
|
+
});
|
|
1151
|
+
socket.on("error", () => {
|
|
1152
|
+
if (!settled) {
|
|
1153
|
+
settled = true;
|
|
1154
|
+
socket.destroy();
|
|
1155
|
+
resolve(false);
|
|
1156
|
+
}
|
|
1157
|
+
});
|
|
1158
|
+
try {
|
|
1159
|
+
socket.connect(port, host);
|
|
1160
|
+
}
|
|
1161
|
+
catch {
|
|
1162
|
+
if (!settled) {
|
|
1163
|
+
settled = true;
|
|
1164
|
+
resolve(false);
|
|
1165
|
+
}
|
|
1166
|
+
}
|
|
1167
|
+
});
|
|
1168
|
+
}
|
|
1169
|
+
}
|
|
1170
|
+
//# sourceMappingURL=scrypted-client.js.map
|