@portalshq/capability-queue-broadcast 0.1.2

package/dist/generated/api.js

@@ -0,0 +1,246 @@
+export const BodyUploadQueueItemMediaType = {
+    video: 'video',
+    image: 'image',
+    audio: 'audio',
+};
+export const HealthResponseMediaServer = {
+    up: 'up',
+    down: 'down',
+};
+export const JobResponseMediaType = {
+    video: 'video',
+    image: 'image',
+    audio: 'audio',
+};
+export const JobResponseStatus = {
+    ingesting: 'ingesting',
+    staged: 'staged',
+    queued: 'queued',
+    generating: 'generating',
+    ready: 'ready',
+    playing: 'playing',
+    done: 'done',
+    failed: 'failed',
+};
+export const QueueItemJsonMediaType = {
+    video: 'video',
+    image: 'image',
+    audio: 'audio',
+};
+export const getGetHealthUrl = () => {
+    return `/health`;
+};
+/**
+ * @summary Health
+ */
+export const getHealth = async (options) => {
+    const res = await fetch(getGetHealthUrl(), {
+        ...options,
+        method: 'GET'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getEnqueueLegacyPromptUrl = () => {
+    return `/v1/prompts`;
+};
+/**
+ * @summary Submit Prompt Compat
+ */
+export const enqueueLegacyPrompt = async (promptInput, options) => {
+    const res = await fetch(getEnqueueLegacyPromptUrl(), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(promptInput)
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetLegacyPromptUrl = (jobId) => {
+    return `/v1/prompts/${jobId}`;
+};
+/**
+ * @summary Prompt Status
+ */
+export const getLegacyPrompt = async (jobId, options) => {
+    const res = await fetch(getGetLegacyPromptUrl(jobId), {
+        ...options,
+        method: 'GET'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getEnqueueQueueItemUrl = () => {
+    return `/v1/queue`;
+};
+/**
+ * @summary Queue Json
+ */
+export const enqueueQueueItem = async (queueItemJson, options) => {
+    const res = await fetch(getEnqueueQueueItemUrl(), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(queueItemJson)
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUploadQueuePairUrl = () => {
+    return `/v1/queue/pairs/upload`;
+};
+/**
+ * Atomically receive finished image and audio bytes from a remote producer.
+ *
+ * The two jobs stay `ingesting` until both files are checksum-verified and
+ * committed. `staged=true` persists the pair without making it eligible for
+ * playout; the authenticated release endpoint activates it later.
+ * @summary Queue Pair Upload
+ */
+export const uploadQueuePair = async (bodyUploadQueuePair, options) => {
+    const formData = new FormData();
+    formData.append(`audio`, bodyUploadQueuePair.audio);
+    formData.append(`audio_sha256`, bodyUploadQueuePair.audio_sha256);
+    formData.append(`image`, bodyUploadQueuePair.image);
+    formData.append(`image_duration`, bodyUploadQueuePair.image_duration.toString());
+    formData.append(`image_sha256`, bodyUploadQueuePair.image_sha256);
+    if (bodyUploadQueuePair.staged !== undefined) {
+        formData.append(`staged`, bodyUploadQueuePair.staged.toString());
+    }
+    const res = await fetch(getUploadQueuePairUrl(), {
+        ...options,
+        method: 'POST',
+        body: formData
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetQueuePairUrl = (pairId) => {
+    return `/v1/queue/pairs/${pairId}`;
+};
+/**
+ * @summary Queue Pair Status
+ */
+export const getQueuePair = async (pairId, options) => {
+    const res = await fetch(getGetQueuePairUrl(pairId), {
+        ...options,
+        method: 'GET'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getReleaseQueuePairUrl = (pairId) => {
+    return `/v1/queue/pairs/${pairId}/release`;
+};
+/**
+ * @summary Release Queue Pair
+ */
+export const releaseQueuePair = async (pairId, options) => {
+    const res = await fetch(getReleaseQueuePairUrl(pairId), {
+        ...options,
+        method: 'POST'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetQueueSlotUrl = (slotKey) => {
+    return `/v1/queue/slots/${slotKey}`;
+};
+/**
+ * @summary Queue Slot Status
+ */
+export const getQueueSlot = async (slotKey, options) => {
+    const res = await fetch(getGetQueueSlotUrl(slotKey), {
+        ...options,
+        method: 'GET'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getReleaseQueueSlotUrl = (slotKey) => {
+    return `/v1/queue/slots/${slotKey}/release`;
+};
+/**
+ * @summary Release Queue Slot
+ */
+export const releaseQueueSlot = async (slotKey, options) => {
+    const res = await fetch(getReleaseQueueSlotUrl(slotKey), {
+        ...options,
+        method: 'POST'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUploadQueueItemUrl = () => {
+    return `/v1/queue/upload`;
+};
+/**
+ * @summary Queue Upload
+ */
+export const uploadQueueItem = async (bodyUploadQueueItem, options) => {
+    const formData = new FormData();
+    if (bodyUploadQueueItem.duration !== undefined && bodyUploadQueueItem.duration !== null) {
+        formData.append(`duration`, bodyUploadQueueItem.duration.toString());
+    }
+    formData.append(`file`, bodyUploadQueueItem.file);
+    if (bodyUploadQueueItem.media_type !== undefined) {
+        formData.append(`media_type`, bodyUploadQueueItem.media_type);
+    }
+    if (bodyUploadQueueItem.sha256 !== undefined && bodyUploadQueueItem.sha256 !== null) {
+        formData.append(`sha256`, bodyUploadQueueItem.sha256);
+    }
+    if (bodyUploadQueueItem.slot_key !== undefined && bodyUploadQueueItem.slot_key !== null) {
+        formData.append(`slot_key`, bodyUploadQueueItem.slot_key);
+    }
+    if (bodyUploadQueueItem.staged !== undefined) {
+        formData.append(`staged`, bodyUploadQueueItem.staged.toString());
+    }
+    const res = await fetch(getUploadQueueItemUrl(), {
+        ...options,
+        method: 'POST',
+        body: formData
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetQueueItemUrl = (jobId) => {
+    return `/v1/queue/${jobId}`;
+};
+/**
+ * @summary Queue Status
+ */
+export const getQueueItem = async (jobId, options) => {
+    const res = await fetch(getGetQueueItemUrl(jobId), {
+        ...options,
+        method: 'GET'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetStreamInfoUrl = () => {
+    return `/v1/stream`;
+};
+/**
+ * @summary Stream Info
+ */
+export const getStreamInfo = async (options) => {
+    const res = await fetch(getGetStreamInfoUrl(), {
+        ...options,
+        method: 'GET'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./client.js";
+export * from "./generated/api.js";
+export * from "./streaming/index.js";
+export * from "./monitoring/metrics.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./client.js";
+// Low-level OpenAPI client. Prefer QueueBroadcastClient for application code.
+export * from "./generated/api.js";
+// Streaming infrastructure
+export * from "./streaming/index.js";
+// Monitoring infrastructure
+export * from "./monitoring/metrics.js";

package/dist/monitoring/metrics.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Simple metrics collection for monitoring streaming infrastructure.
+ * Designed for containerized deployment with HTTP polling instead of WebSocket.
+ */
+export interface MetricsCollector {
+    /** Get current metrics snapshot */
+    getMetrics(): Record<string, unknown>;
+    /** Reset all metrics */
+    reset(): void;
+}
+export interface MetricSnapshot {
+    timestamp: number;
+    component: string;
+    metrics: Record<string, unknown>;
+}
+/**
+ * Simple metrics registry that can collect metrics from multiple components.
+ * Provides HTTP-friendly metrics output for containerized environments.
+ */
+export declare class MetricsRegistry {
+    private collectors;
+    private history;
+    private latestMetrics;
+    private maxHistorySize;
+    constructor(maxHistorySize?: number);
+    /**
+     * Register a metrics collector
+     */
+    register(componentName: string, collector: MetricsCollector): void;
+    /**
+     * Unregister a metrics collector
+     */
+    unregister(componentName: string): void;
+    /**
+     * Collect metrics from all registered components
+     */
+    collectMetrics(): Record<string, MetricSnapshot>;
+    /**
+     * Get latest metrics snapshot
+     */
+    getLatestMetrics(): Record<string, MetricSnapshot> | null;
+    /**
+     * Get metrics history
+     */
+    getHistory(durationMs?: number): MetricSnapshot[];
+    /**
+     * Reset all collectors and history
+     */
+    reset(): void;
+    /**
+     * Export metrics in Prometheus-compatible format
+     */
+    exportPrometheusFormat(): string;
+}
+/**
+ * Simple metrics collector for basic counter and gauge metrics
+ */
+export declare class SimpleMetrics implements MetricsCollector {
+    private counters;
+    private gauges;
+    private labels;
+    /**
+     * Increment a counter
+     */
+    incrementCounter(name: string, value?: number): void;
+    /**
+     * Set a gauge value
+     */
+    setGauge(name: string, value: number): void;
+    /**
+     * Get counter value
+     */
+    getCounter(name: string): number;
+    /**
+     * Get gauge value
+     */
+    getGauge(name: string): number;
+    /**
+     * Set a label (metadata)
+     */
+    setLabel(name: string, value: string): void;
+    /**
+     * Get all metrics
+     */
+    getMetrics(): Record<string, unknown>;
+    /**
+     * Reset all metrics
+     */
+    reset(): void;
+}

package/dist/monitoring/metrics.js

@@ -0,0 +1,190 @@
+/**
+ * Simple metrics collection for monitoring streaming infrastructure.
+ * Designed for containerized deployment with HTTP polling instead of WebSocket.
+ */
+/**
+ * Simple metrics registry that can collect metrics from multiple components.
+ * Provides HTTP-friendly metrics output for containerized environments.
+ */
+export class MetricsRegistry {
+    collectors = new Map();
+    history = [];
+    latestMetrics = null;
+    maxHistorySize;
+    constructor(maxHistorySize = 300) {
+        this.maxHistorySize = maxHistorySize;
+    }
+    /**
+     * Register a metrics collector
+     */
+    register(componentName, collector) {
+        this.collectors.set(componentName, collector);
+    }
+    /**
+     * Unregister a metrics collector
+     */
+    unregister(componentName) {
+        this.collectors.delete(componentName);
+    }
+    /**
+     * Collect metrics from all registered components
+     */
+    collectMetrics() {
+        const timestamp = Date.now();
+        const metrics = {};
+        for (const [componentName, collector] of this.collectors.entries()) {
+            try {
+                const componentMetrics = collector.getMetrics();
+                metrics[componentName] = {
+                    timestamp,
+                    component: componentName,
+                    metrics: componentMetrics,
+                };
+            }
+            catch (error) {
+                metrics[componentName] = {
+                    timestamp,
+                    component: componentName,
+                    metrics: {
+                        error: error instanceof Error ? error.message : String(error),
+                        status: 'error',
+                    },
+                };
+            }
+        }
+        // Add to history
+        const snapshot = {
+            timestamp,
+            component: 'registry',
+            metrics: {
+                totalComponents: this.collectors.size,
+                componentStatuses: Object.fromEntries(Object.entries(metrics).map(([name, snapshot]) => [
+                    name,
+                    snapshot.metrics.error ? 'error' : 'ok',
+                ])),
+            },
+        };
+        this.history.push(snapshot);
+        if (this.history.length > this.maxHistorySize) {
+            this.history.shift();
+        }
+        this.latestMetrics = metrics;
+        return metrics;
+    }
+    /**
+     * Get latest metrics snapshot
+     */
+    getLatestMetrics() {
+        if (this.history.length === 0) {
+            return null;
+        }
+        return this.latestMetrics;
+    }
+    /**
+     * Get metrics history
+     */
+    getHistory(durationMs) {
+        if (!durationMs) {
+            return [...this.history];
+        }
+        const cutoff = Date.now() - durationMs;
+        return this.history.filter(snapshot => snapshot.timestamp >= cutoff);
+    }
+    /**
+     * Reset all collectors and history
+     */
+    reset() {
+        for (const collector of this.collectors.values()) {
+            try {
+                collector.reset();
+            }
+            catch (error) {
+                console.error(`Error resetting collector: ${error}`);
+            }
+        }
+        this.history = [];
+        this.latestMetrics = null;
+    }
+    /**
+     * Export metrics in Prometheus-compatible format
+     */
+    exportPrometheusFormat() {
+        const metrics = this.collectMetrics();
+        const lines = [];
+        for (const [componentName, snapshot] of Object.entries(metrics)) {
+            lines.push(`# Component: ${componentName}`);
+            lines.push(`# Timestamp: ${new Date(snapshot.timestamp).toISOString()}`);
+            for (const [key, value] of Object.entries(snapshot.metrics)) {
+                if (typeof value === 'number') {
+                    lines.push(`${componentName}_${key} ${value}`);
+                }
+                else if (typeof value === 'boolean') {
+                    lines.push(`${componentName}_${key} ${value ? 1 : 0}`);
+                }
+                else if (typeof value === 'string') {
+                    lines.push(`${componentName}_${key} "${value}"`);
+                }
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+}
+/**
+ * Simple metrics collector for basic counter and gauge metrics
+ */
+export class SimpleMetrics {
+    counters = new Map();
+    gauges = new Map();
+    labels = new Map();
+    /**
+     * Increment a counter
+     */
+    incrementCounter(name, value = 1) {
+        const current = this.counters.get(name) || 0;
+        this.counters.set(name, current + value);
+    }
+    /**
+     * Set a gauge value
+     */
+    setGauge(name, value) {
+        this.gauges.set(name, value);
+    }
+    /**
+     * Get counter value
+     */
+    getCounter(name) {
+        return this.counters.get(name) || 0;
+    }
+    /**
+     * Get gauge value
+     */
+    getGauge(name) {
+        return this.gauges.get(name) || 0;
+    }
+    /**
+     * Set a label (metadata)
+     */
+    setLabel(name, value) {
+        this.labels.set(name, value);
+    }
+    /**
+     * Get all metrics
+     */
+    getMetrics() {
+        const metrics = {
+            ...Object.fromEntries(this.counters),
+            ...Object.fromEntries(this.gauges),
+            ...Object.fromEntries(this.labels),
+        };
+        return metrics;
+    }
+    /**
+     * Reset all metrics
+     */
+    reset() {
+        this.counters.clear();
+        this.gauges.clear();
+        this.labels.clear();
+    }
+}

package/dist/streaming/frame-buffer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Frame buffer management for real-time video streaming.
+ * Extracted and adapted from infinite-tv's RTMP streamer patterns.
+ */
+export interface FrameBufferOptions {
+    maxSize?: number;
+}
+/** A bounded FIFO that retains the newest frames when a producer gets ahead. */
+export declare class FrameBuffer<T> {
+    private readonly queue;
+    private readonly maxSize;
+    private framesDropped;
+    private framesAddedTotal;
+    constructor(options?: FrameBufferOptions);
+    /** Adds a frame and returns false when the oldest queued frame was dropped. */
+    addFrame(frame: T): boolean;
+    addFrameBatch(frames: readonly T[]): number;
+    getNextFrame(): T | null;
+    getStatus(): {
+        queueSize: number;
+        maxSize: number;
+        framesDropped: number;
+        framesAddedTotal: number;
+        utilization: number;
+    };
+    /**
+     * Clear the buffer
+     */
+    clear(): void;
+    /**
+     * Reset metrics
+     */
+    resetMetrics(): void;
+}

package/dist/streaming/frame-buffer.js

@@ -0,0 +1,61 @@
+/**
+ * Frame buffer management for real-time video streaming.
+ * Extracted and adapted from infinite-tv's RTMP streamer patterns.
+ */
+/** A bounded FIFO that retains the newest frames when a producer gets ahead. */
+export class FrameBuffer {
+    queue = [];
+    maxSize;
+    framesDropped = 0;
+    framesAddedTotal = 0;
+    constructor(options = {}) {
+        this.maxSize = options.maxSize ?? 1_000;
+        if (!Number.isInteger(this.maxSize) || this.maxSize < 1) {
+            throw new TypeError("maxSize must be a positive integer");
+        }
+    }
+    /** Adds a frame and returns false when the oldest queued frame was dropped. */
+    addFrame(frame) {
+        const droppedFrame = this.queue.length === this.maxSize;
+        if (droppedFrame) {
+            this.queue.shift();
+            this.framesDropped++;
+        }
+        this.queue.push(frame);
+        this.framesAddedTotal++;
+        return !droppedFrame;
+    }
+    addFrameBatch(frames) {
+        let processedCount = 0;
+        for (const frame of frames) {
+            this.addFrame(frame);
+            processedCount++;
+        }
+        return processedCount;
+    }
+    getNextFrame() {
+        return this.queue.shift() ?? null;
+    }
+    getStatus() {
+        return {
+            queueSize: this.queue.length,
+            maxSize: this.maxSize,
+            framesDropped: this.framesDropped,
+            framesAddedTotal: this.framesAddedTotal,
+            utilization: this.queue.length / this.maxSize,
+        };
+    }
+    /**
+     * Clear the buffer
+     */
+    clear() {
+        this.queue.length = 0;
+    }
+    /**
+     * Reset metrics
+     */
+    resetMetrics() {
+        this.framesDropped = 0;
+        this.framesAddedTotal = 0;
+    }
+}

package/dist/streaming/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./frame-buffer.js";
+export * from "./rtmp/rtmp-streamer.js";

package/dist/streaming/index.js

@@ -0,0 +1,2 @@
+export * from "./frame-buffer.js";
+export * from "./rtmp/rtmp-streamer.js";