@camstack/server 1.2.413 → 1.2.415

package/dist/api/trpc/generated-cap-routers.js

@@ -2062,6 +2062,15 @@ function createCapRouter_coreBlocks(getProvider, createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.getCustomization(methodInput);
         }),
+        listComposableCaps: trpc_middleware_js_1.adminProcedure
+            .input(types_34.coreBlocksCapability.methods.listComposableCaps.input.loose())
+            .output(types_34.coreBlocksCapability.methods.listComposableCaps.output)
+            .query(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('core-blocks', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.listComposableCaps(methodInput);
+        }),
         validateComposition: trpc_middleware_js_1.adminProcedure
             .input(types_34.coreBlocksCapability.methods.validateComposition.input.loose())
             .output(types_34.coreBlocksCapability.methods.validateComposition.output)
@@ -7615,6 +7624,14 @@ function createCapRouter_pipelineOrchestrator(getProvider, _createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.getCameraStatuses(input);
         }),
+        setCameraSensors: trpc_middleware_js_1.adminProcedure
+            .input(types_91.pipelineOrchestratorCapability.methods.setCameraSensors.input.loose())
+            .output(types_91.pipelineOrchestratorCapability.methods.setCameraSensors.output)
+            .mutation(async ({ input, ctx }) => {
+            const p = requireCapProvider('pipeline-orchestrator', () => getProvider(ctx));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.setCameraSensors(input);
+        }),
         reconcileFromDisk: trpc_middleware_js_1.adminProcedure
             .input(zod_1.z.object({ nodeId: zod_1.z.string().optional() }).optional())
             .output(types_91.pipelineOrchestratorCapability.methods.reconcileFromDisk.output)

package/dist/core/streaming/ffmpeg-stream-info.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStreamProbeArgs = buildStreamProbeArgs;
+exports.probeFoundAStream = probeFoundAStream;
+exports.parseFfmpegStreamInfo = parseFfmpegStreamInfo;
+/** How long the probe waits on a network input, in µs (ffmpeg's unit). */
+const PROBE_INPUT_TIMEOUT_US = '5000000';
+/**
+ * The probe argv for `url`, chosen by SCHEME.
+ *
+ * The ffmpeg CLI, unlike ffprobe, refuses an input option nothing consumed:
+ * `-rtsp_transport` on an http or file input is `Option rtsp_transport not
+ * found … Error opening input files`, exit 8 (measured on jellyfin 8.1.2).
+ * `-timeout` is an http and rtsp option, is unknown to a file, and on rtmp
+ * would mean LISTEN mode. So each scheme gets exactly what it consumes.
+ */
+function buildStreamProbeArgs(url) {
+    const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(url)?.[1]?.toLowerCase() ?? '';
+    const input = [];
+    if (scheme === 'rtsp' || scheme === 'rtsps') {
+        input.push('-rtsp_transport', 'tcp', '-timeout', PROBE_INPUT_TIMEOUT_US);
+    }
+    else if (scheme === 'http' || scheme === 'https') {
+        input.push('-timeout', PROBE_INPUT_TIMEOUT_US);
+    }
+    return ['-hide_banner', '-nostdin', ...input, '-i', url];
+}
+/** Did the probe find anything at all? An empty result is a failed probe. */
+function probeFoundAStream(meta) {
+    return meta.codec !== undefined || meta.audio !== undefined;
+}
+/** Codec aliases normalised to canonical names. */
+const CODEC_ALIASES = {
+    hevc: 'h265',
+};
+/** `Stream #0:1[0x2](und): Audio: aac (LC) (mp4a / …), …` → kind + the rest. */
+const STREAM_LINE_RE = /^\s*Stream #\d+:\d+\S*:\s+(Video|Audio):\s+(.*)$/;
+/** `aac (LC) (mp4a / 0x…)` → codec `aac`, profile `LC` (the FIRST parenthesis). */
+const CODEC_RE = /^([\w-]+)(?:\s+\(([^)/]+)\))?/;
+/** Channel layouts ffmpeg names instead of counting. */
+const CHANNEL_LAYOUTS = {
+    mono: 1,
+    stereo: 2,
+    '2.1': 3,
+    quad: 4,
+    '5.0': 5,
+    '5.1': 6,
+    '7.1': 8,
+};
+function positive(n) {
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+function kbps(body) {
+    const m = /(\d+) kb\/s/.exec(body);
+    return m === null ? undefined : positive(Number(m[1]));
+}
+function fps(body) {
+    // `fps` is the stream's rate; `tbr` is ffmpeg's guess when it has none.
+    // ffmpeg prints `90k tbr` for 90 000 — the `k` is a multiplier, not noise.
+    const m = /([\d.]+)(k)? fps\b/.exec(body) ?? /([\d.]+)(k)? tbr\b/.exec(body);
+    if (m === null)
+        return undefined;
+    const base = positive(Number(m[1]));
+    if (base === undefined)
+        return undefined;
+    const value = m[2] === 'k' ? base * 1000 : base;
+    return Math.round(value * 100) / 100;
+}
+function readVideo(body, meta) {
+    const codec = CODEC_RE.exec(body);
+    const raw = codec?.[1]?.toLowerCase();
+    if (raw !== undefined)
+        meta.codec = CODEC_ALIASES[raw] ?? raw;
+    const size = /\b(\d{2,5})x(\d{2,5})\b/.exec(body);
+    if (size !== null) {
+        const width = positive(Number(size[1]));
+        const height = positive(Number(size[2]));
+        if (width !== undefined)
+            meta.width = width;
+        if (height !== undefined)
+            meta.height = height;
+    }
+    const rate = fps(body);
+    if (rate !== undefined)
+        meta.fps = rate;
+    const bitrate = kbps(body);
+    if (bitrate !== undefined)
+        meta.bitrateKbps = bitrate;
+}
+function readAudio(body) {
+    const audio = {};
+    const codec = CODEC_RE.exec(body);
+    if (codec?.[1] !== undefined)
+        audio.codec = codec[1].toLowerCase();
+    const profile = codec?.[2]?.trim();
+    if (profile !== undefined && profile.length > 0)
+        audio.profile = profile;
+    const hz = /(\d+) Hz/.exec(body);
+    if (hz !== null) {
+        const sampleRate = positive(Number(hz[1]));
+        if (sampleRate !== undefined)
+            audio.sampleRate = sampleRate;
+    }
+    const fields = body.split(',').map((f) => f.trim());
+    for (const field of fields) {
+        const named = CHANNEL_LAYOUTS[field.replace(/\(.*\)$/, '')];
+        if (named !== undefined) {
+            audio.channels = named;
+            break;
+        }
+        const counted = /^(\d+) channels$/.exec(field);
+        if (counted !== null) {
+            audio.channels = Number(counted[1]);
+            break;
+        }
+    }
+    const bitrate = kbps(body);
+    if (bitrate !== undefined)
+        audio.bitrateKbps = bitrate;
+    return audio;
+}
+/** The FIRST video and FIRST audio stream of `ffmpeg -i`'s report. */
+function parseFfmpegStreamInfo(stderr) {
+    const meta = {};
+    // CRLF too: `(.*)$` cannot cross a `\r`, and a Windows build or a captured
+    // log hands one over.
+    for (const line of stderr.split(/\r?\n/)) {
+        const m = STREAM_LINE_RE.exec(line);
+        if (m === null)
+            continue;
+        const kind = m[1];
+        const body = m[2] ?? '';
+        if (kind === 'Video' && meta.codec === undefined)
+            readVideo(body, meta);
+        else if (kind === 'Audio' && meta.audio === undefined)
+            meta.audio = readAudio(body);
+    }
+    return meta;
+}

package/dist/core/streaming/stream-probe.service.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamProbeService = void 0;
 const child_process_1 = require("child_process");
-const util_1 = require("util");
 const ttl_cache_1 = require("./ttl-cache");
 const types_1 = require("@camstack/types");
-const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const ffmpeg_stream_info_1 = require("./ffmpeg-stream-info");
 const CACHE_TTL_MS = 3_600_000; // 1 hour
 const PROBE_TIMEOUT_MS = 5_000;
 /**
@@ -18,11 +17,13 @@ const PROBE_TIMEOUT_MS = 5_000;
  * the ceiling exists so the key space cannot be walked into the OOM.
  */
 const CACHE_MAX_ENTRIES = 512;
-/** Codec aliases normalised to canonical names. */
-const CODEC_ALIASES = {
-    hevc: 'h265',
-};
+/** A probe URL — and ffmpeg's echo of it — carries the camera's credentials;
+ *  the log never does. */
+function redactUrl(text) {
+    return text.replace(/\/\/[^@/\s]*@/g, '//***@');
+}
 class StreamProbeService {
+    resolveFfmpeg;
     logger;
     /**
      * Probe results, bounded by BOTH a swept TTL and an entry ceiling.
@@ -35,7 +36,10 @@ class StreamProbeService {
         ttlMs: CACHE_TTL_MS,
         maxEntries: CACHE_MAX_ENTRIES,
     });
-    constructor(loggingService) {
+    constructor(loggingService, 
+    /** The node's pinned ffmpeg (D540). Rejects rather than naming PATH. */
+    resolveFfmpeg) {
+        this.resolveFfmpeg = resolveFfmpeg;
         this.logger = loggingService.createLogger('StreamProbeService');
     }
     // ---------------------------------------------------------------------------
@@ -50,19 +54,24 @@ class StreamProbeService {
                 return cached;
         }
         const metadata = await this.runProbe(url);
-        this.cache.set(url, metadata);
+        // Only an ANSWER is cached. An empty result is a probe that failed (no
+        // binary, a timeout, a refused dial), and caching it for an hour made one
+        // bad moment the answer for an hour.
+        if ((0, ffmpeg_stream_info_1.probeFoundAStream)(metadata))
+            this.cache.set(url, metadata);
         return metadata;
     }
     /**
      * Generic field probe: given a field key and value, decides how to probe.
-     * Stream fields (stream_*) → ffprobe, other URLs → HTTP HEAD check.
+     * Stream fields (stream_*) → the pinned ffmpeg's input report, other URLs →
+     * HTTP HEAD check.
      */
     async probeField(key, value) {
         const url = String(value ?? '').trim();
         if (!url) {
             return { status: 'error', error: 'No URL provided' };
         }
-        // Stream fields: use ffprobe
+        // Stream fields: ask the pinned ffmpeg what the input carries
         if (key.startsWith('stream')) {
             const meta = await this.probe(url, { force: true });
             const labels = [];
@@ -132,98 +141,31 @@ class StreamProbeService {
     // Internal
     // ---------------------------------------------------------------------------
     async runProbe(url) {
+        // The node's PINNED ffmpeg (D540). This was `ffprobe` spawned by name —
+        // the host's binary, off PATH, which the pinned build does not even ship.
+        let ffmpeg;
         try {
-            // Query first video + first audio stream in one ffprobe pass.
-            // `-show_streams` returns every stream in the container; we filter
-            // by codec_type when parsing. Fields cover both kinds.
-            const { stdout } = await execFileAsync('ffprobe', [
-                '-v',
-                'error',
-                '-rtsp_transport',
-                'tcp',
-                '-timeout',
-                '5000000',
-                '-show_entries',
-                'stream=codec_type,codec_name,profile,width,height,r_frame_rate,bit_rate,sample_rate,channels',
-                '-of',
-                'json',
-                url,
-            ], { timeout: PROBE_TIMEOUT_MS });
-            return this.parseOutput(stdout);
+            ffmpeg = await this.resolveFfmpeg();
         }
         catch (err) {
-            this.logger.error('ffprobe failed', { meta: { url, error: String(err) } });
+            this.logger.error('stream probe refused — no pinned ffmpeg on this node (D540)', {
+                meta: { url: redactUrl(url), error: (0, types_1.errMsg)(err) },
+            });
             return {};
         }
-    }
-    parseOutput(stdout) {
-        const parsed = JSON.parse(stdout);
-        const streams = parsed.streams;
-        if (!Array.isArray(streams) || streams.length === 0) {
-            return {};
-        }
-        const meta = {};
-        for (const raw of streams) {
-            const stream = raw;
-            const codecType = typeof stream.codec_type === 'string' ? stream.codec_type : undefined;
-            if (codecType === 'video' && meta.codec === undefined) {
-                const rawCodec = typeof stream.codec_name === 'string' ? stream.codec_name : undefined;
-                meta.codec = rawCodec ? (CODEC_ALIASES[rawCodec] ?? rawCodec) : undefined;
-                if (typeof stream.width === 'number')
-                    meta.width = stream.width;
-                if (typeof stream.height === 'number')
-                    meta.height = stream.height;
-                const fps = this.parseFps(stream.r_frame_rate);
-                if (fps !== undefined)
-                    meta.fps = fps;
-                const bitrateKbps = this.parseBitrateKbps(stream.bit_rate);
-                if (bitrateKbps !== undefined)
-                    meta.bitrateKbps = bitrateKbps;
-            }
-            else if (codecType === 'audio' && meta.audio === undefined) {
-                const audio = {};
-                if (typeof stream.codec_name === 'string')
-                    audio.codec = stream.codec_name;
-                if (typeof stream.profile === 'string')
-                    audio.profile = stream.profile;
-                const sampleRate = this.parseIntField(stream.sample_rate);
-                if (sampleRate !== undefined)
-                    audio.sampleRate = sampleRate;
-                if (typeof stream.channels === 'number')
-                    audio.channels = stream.channels;
-                const audioBitrateKbps = this.parseBitrateKbps(stream.bit_rate);
-                if (audioBitrateKbps !== undefined)
-                    audio.bitrateKbps = audioBitrateKbps;
-                meta.audio = audio;
-            }
+        // `-i` with no output: ffmpeg reports every input stream on stderr, then
+        // exits non-zero for want of an output. That exit is the expected one, so
+        // the report is read whatever the code; an empty report is the failure.
+        const stderr = await new Promise((resolve) => {
+            (0, child_process_1.execFile)(ffmpeg, (0, ffmpeg_stream_info_1.buildStreamProbeArgs)(url), { timeout: PROBE_TIMEOUT_MS, encoding: 'utf8' }, (_err, _stdout, errText) => resolve(errText));
+        });
+        const metadata = (0, ffmpeg_stream_info_1.parseFfmpegStreamInfo)(stderr);
+        if (!(0, ffmpeg_stream_info_1.probeFoundAStream)(metadata)) {
+            this.logger.error('stream probe found no stream', {
+                meta: { url: redactUrl(url), stderr: redactUrl(stderr.trim().slice(-500)) },
+            });
         }
-        return meta;
-    }
-    parseIntField(value) {
-        const n = typeof value === 'string' ? Number(value) : typeof value === 'number' ? value : NaN;
-        if (!Number.isFinite(n) || n <= 0)
-            return undefined;
-        return Math.round(n);
-    }
-    /** Parse fractional frame rate string like "25/1" → 25. */
-    parseFps(value) {
-        if (typeof value !== 'string')
-            return undefined;
-        const parts = value.split('/');
-        if (parts.length !== 2)
-            return undefined;
-        const num = Number(parts[0]);
-        const den = Number(parts[1]);
-        if (!Number.isFinite(num) || !Number.isFinite(den) || den === 0)
-            return undefined;
-        return Math.round((num / den) * 100) / 100;
-    }
-    /** Parse bit_rate string (bps) → kbps. */
-    parseBitrateKbps(value) {
-        const n = typeof value === 'string' ? Number(value) : typeof value === 'number' ? value : NaN;
-        if (!Number.isFinite(n) || n <= 0)
-            return undefined;
-        return Math.round(n / 1000);
+        return metadata;
     }
 }
 exports.StreamProbeService = StreamProbeService;

package/dist/manual-boot.js

@@ -139,7 +139,11 @@ async function bootManual(opts) {
     loggingService.setDestinationEnabledCheck((addonId) => capabilityService.getRegistry()?.isProviderDisabled('log-destination', addonId) !== true);
     const featureService = new feature_service_1.FeatureService(configService);
     const authService = new auth_service_1.AuthService(configService);
-    const streamProbeService = new stream_probe_service_1.StreamProbeService(loggingService);
+    // The probe runs the node's PINNED ffmpeg (D540) — resolved through the same
+    // deps manager every addon is given, once, and never looked up on PATH.
+    // (The manager roots binaries at the NODE's data dir whatever it is given.)
+    const probeDeps = new system_1.AddonDepsManager(path.resolve(process.env['CAMSTACK_DATA'] ?? 'camstack-data'), loggingService.createLogger('StreamProbeDeps'));
+    const streamProbeService = new stream_probe_service_1.StreamProbeService(loggingService, (0, types_1.memoizePinnedFfmpeg)(() => probeDeps.ensureFfmpeg()));
     const addonBridgeService = new addon_bridge_service_1.AddonBridgeService(loggingService);
     const addonSearchService = new addon_search_service_1.AddonSearchService(loggingService);
     // ---- Layer 2: need Layer 0/1 -------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.2.413",
+  "version": "1.2.415",
   "license": "MIT",
   "private": false,
   "files": [
@@ -37,18 +37,18 @@
     ]
   },
   "dependencies": {
-    "@camstack/addon-admin-ui": "1.2.288",
-    "@camstack/addon-agent-ui": "1.2.156",
+    "@camstack/addon-admin-ui": "1.2.290",
+    "@camstack/addon-agent-ui": "1.2.157",
     "@camstack/addon-auth": "1.2.123",
     "@camstack/addon-decoder-nodeav": "1.2.115",
     "@camstack/addon-notifiers": "1.2.121",
-    "@camstack/addon-pipeline": "1.2.307",
-    "@camstack/addon-pipeline-orchestrator": "1.2.264",
-    "@camstack/addon-post-analysis": "1.2.299",
+    "@camstack/addon-pipeline": "1.2.308",
+    "@camstack/addon-pipeline-orchestrator": "1.2.265",
+    "@camstack/addon-post-analysis": "1.2.300",
     "@camstack/sdk": "1.2.118",
-    "@camstack/system": "1.2.321",
-    "@camstack/types": "1.2.274",
-    "@camstack/ui-library": "1.2.214",
+    "@camstack/system": "1.2.323",
+    "@camstack/types": "1.2.276",
+    "@camstack/ui-library": "1.2.215",
     "@fastify/compress": "^9.0.0",
     "@fastify/cookie": "^11.0.2",
     "@fastify/cors": "^11.2.0",