@norskvideo/ctl-sdk 0.1.0

package/proxy-middleware.js

@@ -0,0 +1,112 @@
+import { logger } from "@norskvideo/ctl-foundation";
+const HOP_BY_HOP = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailers",
+    "transfer-encoding",
+    "upgrade",
+    "host",
+    "content-length",
+]);
+function targetBaseUrl(reg) {
+    if (reg.spec.kind === "container") {
+        return reg.port !== undefined ? `http://127.0.0.1:${reg.port}` : null;
+    }
+    return reg.spec.url.replace(/\/$/, "");
+}
+function buildOutgoingHeaders(req) {
+    const out = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (HOP_BY_HOP.has(key.toLowerCase()))
+            continue;
+        if (value === undefined)
+            continue;
+        out[key] = Array.isArray(value) ? value.join(", ") : value;
+    }
+    return out;
+}
+async function readRequestBody(req) {
+    if (req.method === "GET" || req.method === "HEAD")
+        return undefined;
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => {
+            if (!chunks.length)
+                return resolve(undefined);
+            const buf = Buffer.concat(chunks);
+            resolve(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
+        });
+        req.on("error", reject);
+    });
+}
+export function createProductProxyMiddleware(svc) {
+    return async (req, res, next) => {
+        const name = req.params.name;
+        if (typeof name !== "string" || !name)
+            return next();
+        const registrations = svc.list();
+        const reg = registrations.find((p) => p.name === name);
+        if (!reg) {
+            res.status(404).json({ status: "error", message: `unknown product '${name}'` });
+            return;
+        }
+        const base = targetBaseUrl(reg);
+        if (!base) {
+            res.status(502).json({ status: "error", message: `product '${name}' has no reachable base URL` });
+            return;
+        }
+        const targetUrl = `${base}${req.url}`;
+        const headers = buildOutgoingHeaders(req);
+        const body = await readRequestBody(req);
+        let upstream;
+        try {
+            upstream = await fetch(targetUrl, {
+                method: req.method,
+                headers,
+                body: body,
+                redirect: "manual",
+            });
+        }
+        catch (e) {
+            logger.warn(`Proxy to ${targetUrl} failed: ${String(e)}`);
+            res.status(502).json({ status: "error", message: `upstream fetch failed: ${String(e)}` });
+            return;
+        }
+        res.status(upstream.status);
+        const productPrefix = `/products/${encodeURIComponent(name)}`;
+        upstream.headers.forEach((value, key) => {
+            const lower = key.toLowerCase();
+            if (HOP_BY_HOP.has(lower))
+                return;
+            // Rewrite root-absolute redirect Locations so 3xx responses don't
+            // escape the product prefix and land on the runner SPA. Relative
+            // (non-/-prefixed) and full-URL Locations pass through unchanged.
+            if (lower === "location" && value.startsWith("/") && !value.startsWith("//")) {
+                res.setHeader(key, `${productPrefix}${value}`);
+                return;
+            }
+            res.setHeader(key, value);
+        });
+        if (!upstream.body) {
+            res.end();
+            return;
+        }
+        const reader = upstream.body.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                res.write(value);
+            }
+        }
+        catch (e) {
+            logger.warn(`Proxy stream from ${targetUrl} broke: ${String(e)}`);
+        }
+        res.end();
+    };
+}

package/runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function setBasename(b: string): void;
+export declare function getBasename(): string;

package/runtime.js

@@ -0,0 +1,21 @@
+// Shared basename state for a product's configure UI. Authoritative source is
+// `init.instanceContext.basename` from the runner; we fall back to deriving it
+// from the URL pre-init so that fetches before init lands and standalone usage
+// both work without a special case. Set once on init, read everywhere.
+//
+// Reached via "@norskvideo/ctl-sdk/runtime" rather than the browser barrel: this has no
+// dependencies, and the barrel would pull the zod-backed schema surface into a
+// frontend that only wants a URL prefix.
+let basename = null;
+export function setBasename(b) {
+    basename = b;
+}
+export function getBasename() {
+    if (basename !== null)
+        return basename;
+    // Fallback: strip the `/configure/...` suffix from the iframe's URL.
+    // Standalone (`/configure/`) → "". Proxied (`/products/<name>/configure/`)
+    // → "/products/<name>". Ensures fetch URLs work before `init` arrives.
+    const m = window.location.pathname.match(/^(.*?)\/configure(\/|$)/);
+    return m ? m[1] : "";
+}

package/validate.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationResult } from "@norskvideo/ctl-foundation/browser";
+export declare function validateInstanceId(id: string): ValidationResult;
+export declare function isValidInstanceId(id: string): boolean;

package/validate.js

@@ -0,0 +1,22 @@
+const ID_PATTERN = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
+export function validateInstanceId(id) {
+    if (id.length === 0) {
+        return { status: "error", message: "Instance ID must not be empty" };
+    }
+    if (id.length > 63) {
+        return { status: "error", message: "Instance ID must be 63 characters or fewer" };
+    }
+    if (id.startsWith("-")) {
+        return { status: "error", message: "Instance ID must not start with a hyphen" };
+    }
+    if (id.endsWith("-")) {
+        return { status: "error", message: "Instance ID must not end with a hyphen" };
+    }
+    if (!ID_PATTERN.test(id)) {
+        return { status: "error", message: "Instance ID must contain only lowercase letters, digits, and hyphens" };
+    }
+    return { status: "valid" };
+}
+export function isValidInstanceId(id) {
+    return validateInstanceId(id).status === "valid";
+}

package/workflow.d.ts

@@ -0,0 +1,60 @@
+export type SubscriptionFilter = {
+    media: "video" | "audio" | "subtitle" | "ancillary" | "playlist";
+    renditionName?: string;
+    sourceName?: string;
+    programNumber?: number;
+    streamId?: number;
+};
+export type SubscriptionStreams = {
+    type: "take-all-streams";
+    filter: SubscriptionFilter[];
+} | {
+    type: "take-first-stream";
+    filter: SubscriptionFilter[];
+} | {
+    type: "take-specific-streams";
+    filter: SubscriptionFilter[];
+};
+export type Subscription = {
+    source: string;
+    streams: SubscriptionStreams;
+};
+export type WorkflowComponent<Config = Record<string, unknown>> = {
+    type: string;
+    config: Config;
+    subscriptions: Subscription[];
+};
+export type LayoutInfo = {
+    id: string;
+    x: number;
+    y: number;
+};
+export type WorkflowDoc = {
+    components: WorkflowComponent[];
+    __layout?: LayoutInfo[];
+    __globalConfig?: Record<string, unknown>;
+};
+export declare const ALL_AV: SubscriptionStreams;
+export declare const VIDEO_ONLY: SubscriptionStreams;
+export declare const AUDIO_ONLY: SubscriptionStreams;
+export declare const FIRST_VIDEO: SubscriptionStreams;
+export declare const FIRST_AUDIO: SubscriptionStreams;
+export type SyntheticNodeInfo = {
+    identifier: string;
+    subscription: {
+        accepts: {
+            type: "simple-stream";
+            video: true;
+            audio: true;
+            subtitle: true;
+            ancillary: true;
+            playlist: true;
+            acceptsTransient: true;
+        };
+        produces: {
+            type: "dynamic-streams";
+            streams: <S>(cfg: unknown, inputStreams: S) => S;
+        };
+    };
+};
+export declare function syntheticInfo<T = SyntheticNodeInfo>(identifier: string): T;

package/workflow.js

@@ -0,0 +1,57 @@
+// Shared Studio-workflow document shape and the product-agnostic subscription
+// constants, consolidated from the four media-graph products' identical
+// `shared/src/workflow/types.ts` cores. This is the structural shape of the
+// Studio YAML each product emits — zero runtime dependencies, so it lives on
+// its own `./workflow` sdk subpath rather than the `.` barrel (which drags
+// express). Product-specific consts (probe's MARKERS_AND_CAPTIONS, funke's
+// ANCILLARY_ONLY) and per-product document extensions (probe's `__signature`)
+// stay in each product's own `types.ts`.
+export const ALL_AV = {
+    type: "take-all-streams",
+    filter: [{ media: "video" }, { media: "audio" }],
+};
+export const VIDEO_ONLY = {
+    type: "take-all-streams",
+    filter: [{ media: "video" }],
+};
+export const AUDIO_ONLY = {
+    type: "take-all-streams",
+    filter: [{ media: "audio" }],
+};
+export const FIRST_VIDEO = {
+    type: "take-first-stream",
+    filter: [{ media: "video" }],
+};
+export const FIRST_AUDIO = {
+    type: "take-first-stream",
+    filter: [{ media: "audio" }],
+};
+// A permissive builder NodeInfo for an identifier the real component library
+// does not know (a product's own component, or an alpha/custom node that lives
+// only in the running studio image). It accepts any media and PASSES INPUT
+// STREAMS THROUGH unchanged, so a node downstream of a synthetic resolves the
+// same streams it would against the real component and the emitted subscriptions
+// match the hand-written ones. Synthetic nodes are not stream/config-validated,
+// but any edge whose SOURCE is a real built-in still validates against it.
+//
+// Generic over the caller's builder NodeInfo type so sdk needs no
+// norsk-studio-builder dependency: each product infers `T` from the position it
+// assigns the result to (a `find(): NodeInfoForBuilder | undefined`), and the
+// body's structure is checked against that `T` at the call site.
+export function syntheticInfo(identifier) {
+    return {
+        identifier,
+        subscription: {
+            accepts: {
+                type: "simple-stream",
+                video: true,
+                audio: true,
+                subtitle: true,
+                ancillary: true,
+                playlist: true,
+                acceptsTransient: true,
+            },
+            produces: { type: "dynamic-streams", streams: (_cfg, inputStreams) => inputStreams },
+        },
+    };
+}