@basmilius/apple-rtsp 0.9.17

package/dist/index.d.mts

@@ -0,0 +1,54 @@
+import { Connection, Context } from "@basmilius/apple-common";
+
+//#region src/encoding.d.ts
+type Method = "ANNOUNCE" | "FLUSH" | "GET" | "GET_PARAMETER" | "OPTIONS" | "POST" | "PUT" | "RECORD" | "SETUP" | "SET_PARAMETER" | "TEARDOWN";
+type RtspRequest = {
+  readonly headers: Record<string, string>;
+  readonly method: Method;
+  readonly path: string;
+  readonly body: Buffer;
+  readonly requestLength: number;
+};
+type RtspResponse = {
+  readonly response: Response;
+  readonly responseLength: number;
+};
+type BuildResponseOptions = {
+  readonly status: number;
+  readonly statusText: string;
+  readonly headers?: Record<string, string | number>;
+  readonly body?: Buffer;
+  readonly protocol?: "RTSP/1.0" | "HTTP/1.1";
+};
+declare function buildResponse(options: BuildResponseOptions): Buffer;
+declare function parseRequest(buffer: Buffer): RtspRequest | null;
+declare function parseResponse(buffer: Buffer): RtspResponse | null;
+//#endregion
+//#region src/client.d.ts
+type ExchangeOptions = {
+  contentType?: string;
+  headers?: Record<string, string>;
+  body?: Buffer | string | Record<string, unknown>;
+  allowError?: boolean;
+  protocol?: "RTSP/1.0" | "HTTP/1.1";
+  timeout?: number;
+};
+declare class RtspClient extends Connection<{}> {
+  #private;
+  constructor(context: Context, address: string, port: number);
+  /**
+  * Override to provide default headers for every request.
+  */
+  protected getDefaultHeaders(): Record<string, string | number>;
+  /**
+  * Override to transform incoming data before RTSP parsing (e.g. decryption).
+  */
+  protected transformIncoming(data: Buffer): Buffer | false;
+  /**
+  * Override to transform outgoing data after RTSP formatting (e.g. encryption).
+  */
+  protected transformOutgoing(data: Buffer): Buffer;
+  protected exchange(method: Method, path: string, options?: ExchangeOptions): Promise<Response>;
+}
+//#endregion
+export { type BuildResponseOptions, type ExchangeOptions, type Method, RtspClient, type RtspRequest, type RtspResponse, buildResponse, parseRequest, parseResponse };

package/dist/index.mjs

@@ -0,0 +1,221 @@
+import { Connection, HTTP_TIMEOUT } from "@basmilius/apple-common";
+import { Plist } from "@basmilius/apple-encoding";
+
+//#region src/encoding.ts
+function buildResponse(options) {
+	const { status, statusText, headers: extraHeaders = {}, body, protocol = "RTSP/1.0" } = options;
+	const headers = {
+		...extraHeaders,
+		"Content-Length": body?.byteLength ?? 0
+	};
+	const headerLines = [
+		`${protocol} ${status} ${statusText}`,
+		...Object.entries(headers).map(([k, v]) => `${k}: ${v}`),
+		"",
+		""
+	].join("\r\n");
+	if (body && body.byteLength > 0) return Buffer.concat([Buffer.from(headerLines), body]);
+	return Buffer.from(headerLines);
+}
+function parseRequest(buffer) {
+	const headerLength = buffer.indexOf("\r\n\r\n");
+	const { headers, method, path } = parseRequestHeaders(buffer.subarray(0, headerLength));
+	let contentLength = headers["Content-Length"] ? Number(headers["Content-Length"]) : 0;
+	if (isNaN(contentLength)) contentLength = 0;
+	const requestLength = headerLength + 4 + contentLength;
+	if (buffer.byteLength < requestLength) return null;
+	return {
+		headers,
+		method,
+		path,
+		body: buffer.subarray(headerLength + 4, requestLength),
+		requestLength
+	};
+}
+function parseResponse(buffer) {
+	const headerLength = buffer.indexOf("\r\n\r\n");
+	const { headers, status, statusText } = parseResponseHeaders(buffer.subarray(0, headerLength));
+	let contentLength = headers["Content-Length"] ? Number(headers["Content-Length"]) : 0;
+	if (isNaN(contentLength)) contentLength = 0;
+	const responseLength = headerLength + 4 + contentLength;
+	if (buffer.byteLength < responseLength) return null;
+	const body = buffer.subarray(headerLength + 4, responseLength);
+	return {
+		response: new Response(body, {
+			status,
+			statusText,
+			headers
+		}),
+		responseLength
+	};
+}
+function parseHeaders(lines) {
+	const headers = {};
+	for (let i = 0; i < lines.length; i++) {
+		const colon = lines[i].indexOf(":");
+		if (colon <= 0) continue;
+		const name = lines[i].substring(0, colon).trim();
+		headers[name] = lines[i].substring(colon + 1).trim();
+	}
+	return headers;
+}
+function parseRequestHeaders(buffer) {
+	const lines = buffer.toString("utf8").split("\r\n");
+	const rawRequest = lines[0].match(/^(\S+)\s+(\S+)\s+RTSP\/1\.0$/);
+	if (!rawRequest) throw new Error(`Invalid RTSP request line: ${lines[0]}`);
+	const method = rawRequest[1];
+	const path = rawRequest[2];
+	return {
+		headers: parseHeaders(lines.slice(1)),
+		method,
+		path
+	};
+}
+function parseResponseHeaders(buffer) {
+	const lines = buffer.toString("utf8").split("\r\n");
+	const rawStatus = lines[0].match(/(HTTP|RTSP)\/[\d.]+\s+(\d+)\s+(.+)/);
+	if (!rawStatus) throw new Error(`Invalid RTSP/HTTP response line: ${lines[0]}`);
+	const status = Number(rawStatus[2]);
+	const statusText = rawStatus[3];
+	return {
+		headers: parseHeaders(lines.slice(1)),
+		status,
+		statusText
+	};
+}
+
+//#endregion
+//#region src/client.ts
+const MAX_BUFFER_SIZE = 2 * 1024 * 1024;
+var RtspClient = class extends Connection {
+	#buffer = Buffer.alloc(0);
+	#cseq = 0;
+	#requests = /* @__PURE__ */ new Map();
+	constructor(context, address, port) {
+		super(context, address, port);
+		this.on("close", this.#onClose.bind(this));
+		this.on("data", this.#onData.bind(this));
+		this.on("error", this.#onError.bind(this));
+		this.on("timeout", this.#onTimeout.bind(this));
+	}
+	/**
+	* Override to provide default headers for every request.
+	*/
+	getDefaultHeaders() {
+		return {};
+	}
+	/**
+	* Override to transform incoming data before RTSP parsing (e.g. decryption).
+	*/
+	transformIncoming(data) {
+		return data;
+	}
+	/**
+	* Override to transform outgoing data after RTSP formatting (e.g. encryption).
+	*/
+	transformOutgoing(data) {
+		return data;
+	}
+	async exchange(method, path, options = {}) {
+		const { contentType, headers: extraHeaders = {}, allowError = false, protocol = "RTSP/1.0", timeout = HTTP_TIMEOUT } = options;
+		let { body } = options;
+		const cseq = this.#cseq++;
+		const headers = {
+			"CSeq": cseq,
+			...this.getDefaultHeaders(),
+			...extraHeaders
+		};
+		let bodyBuffer;
+		if (body && typeof body === "object" && !Buffer.isBuffer(body)) {
+			bodyBuffer = Buffer.from(Plist.serialize(body));
+			headers["Content-Type"] = "application/x-apple-binary-plist";
+		} else if (body) {
+			bodyBuffer = typeof body === "string" ? Buffer.from(body) : body;
+			if (contentType) headers["Content-Type"] = contentType;
+		} else if (contentType) headers["Content-Type"] = contentType;
+		if (bodyBuffer) headers["Content-Length"] = bodyBuffer.length;
+		else headers["Content-Length"] = 0;
+		const headerLines = [
+			`${method} ${path} ${protocol}`,
+			...Object.entries(headers).map(([k, v]) => `${k}: ${v}`),
+			"",
+			""
+		].join("\r\n");
+		const raw = bodyBuffer ? Buffer.concat([Buffer.from(headerLines), bodyBuffer]) : Buffer.from(headerLines);
+		const data = this.transformOutgoing(Buffer.from(raw));
+		this.context.logger.net("[rtsp]", method, path, `cseq=${cseq}`);
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.#requests.delete(cseq);
+				reject(/* @__PURE__ */ new Error(`No response to CSeq ${cseq} (${path})`));
+			}, timeout);
+			this.#requests.set(cseq, {
+				resolve: (response) => {
+					clearTimeout(timer);
+					if (!allowError && !response.ok) reject(/* @__PURE__ */ new Error(`RTSP error: ${response.status} ${response.statusText}`));
+					else resolve(response);
+				},
+				reject: (error) => {
+					clearTimeout(timer);
+					reject(error);
+				}
+			});
+			this.write(data);
+		});
+	}
+	#onClose() {
+		this.#buffer = Buffer.alloc(0);
+		for (const [cseq, { reject }] of this.#requests) {
+			reject(/* @__PURE__ */ new Error("Connection closed"));
+			this.#requests.delete(cseq);
+		}
+		this.context.logger.net("[rtsp]", "#onClose()");
+	}
+	#onData(data) {
+		try {
+			this.#buffer = Buffer.concat([this.#buffer, data]);
+			if (this.#buffer.byteLength > MAX_BUFFER_SIZE) {
+				this.context.logger.error("[rtsp]", `Buffer exceeded max size (${this.#buffer.byteLength} bytes), resetting.`);
+				this.#buffer = Buffer.alloc(0);
+				this.emit("error", /* @__PURE__ */ new Error("Buffer overflow: exceeded maximum buffer size"));
+				return;
+			}
+			const transformed = this.transformIncoming(this.#buffer);
+			if (transformed === false) return;
+			this.#buffer = transformed;
+			while (this.#buffer.byteLength > 0) {
+				const result = parseResponse(this.#buffer);
+				if (result === null) return;
+				this.#buffer = this.#buffer.subarray(result.responseLength);
+				const cseqHeader = result.response.headers.get("CSeq");
+				const cseq = cseqHeader ? parseInt(cseqHeader, 10) : -1;
+				if (this.#requests.has(cseq)) {
+					const { resolve } = this.#requests.get(cseq);
+					this.#requests.delete(cseq);
+					resolve(result.response);
+				} else this.context.logger.warn("[rtsp]", `Unexpected response for CSeq ${cseq}`);
+			}
+		} catch (err) {
+			this.context.logger.error("[rtsp]", "#onData()", err);
+			this.emit("error", err);
+		}
+	}
+	#onError(err) {
+		for (const [cseq, { reject }] of this.#requests) {
+			reject(err);
+			this.#requests.delete(cseq);
+		}
+		this.context.logger.error("[rtsp]", "#onError()", err);
+	}
+	#onTimeout() {
+		const err = /* @__PURE__ */ new Error("Connection timed out");
+		for (const [cseq, { reject }] of this.#requests) {
+			reject(err);
+			this.#requests.delete(cseq);
+		}
+		this.context.logger.net("[rtsp]", "#onTimeout()");
+	}
+};
+
+//#endregion
+export { RtspClient, buildResponse, parseRequest, parseResponse };

package/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "@basmilius/apple-rtsp",
+    "description": "RTSP protocol implementation for Apple Protocols.",
+    "version": "0.9.17",
+    "type": "module",
+    "license": "MIT",
+    "author": {
+        "name": "Bas Milius",
+        "email": "bas@mili.us",
+        "url": "https://bas.dev"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/basmilius/apple-protocols",
+        "directory": "packages/rtsp"
+    },
+    "keywords": [
+        "apple",
+        "airplay",
+        "rtsp"
+    ],
+    "files": [
+        "dist",
+        "LICENSE"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": false
+    },
+    "scripts": {
+        "build": "tsgo --noEmit && tsdown",
+        "dev": "tsdown --watch"
+    },
+    "main": "./dist/index.mjs",
+    "types": "./dist/index.d.mts",
+    "typings": "./dist/index.d.mts",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.mts",
+            "default": "./dist/index.mjs"
+        }
+    },
+    "dependencies": {
+        "@basmilius/apple-common": "workspace:*",
+        "@basmilius/apple-encoding": "workspace:*"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.11",
+        "@types/node": "^25.5.0",
+        "tsdown": "^0.21.4"
+    }
+}