@f5-sales-demo/xcsh 20.15.2 → 20.16.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/xcsh",
-	"version": "20.15.2",
+	"version": "20.16.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -61,13 +61,13 @@
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "1.3.0",
-		"@f5-sales-demo/pi-agent-core": "20.15.2",
-		"@f5-sales-demo/pi-ai": "20.15.2",
-		"@f5-sales-demo/pi-natives": "20.15.2",
-		"@f5-sales-demo/pi-resource-management": "20.15.2",
-		"@f5-sales-demo/pi-tui": "20.15.2",
-		"@f5-sales-demo/pi-utils": "20.15.2",
-		"@f5-sales-demo/xcsh-stats": "20.15.2",
+		"@f5-sales-demo/pi-agent-core": "20.16.0",
+		"@f5-sales-demo/pi-ai": "20.16.0",
+		"@f5-sales-demo/pi-natives": "20.16.0",
+		"@f5-sales-demo/pi-resource-management": "20.16.0",
+		"@f5-sales-demo/pi-tui": "20.16.0",
+		"@f5-sales-demo/pi-utils": "20.16.0",
+		"@f5-sales-demo/xcsh-stats": "20.16.0",
 		"@mozilla/readability": "^0.6",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",

package/src/config/settings-schema.ts

@@ -433,6 +433,24 @@ export const SETTINGS_SCHEMA = {
 		ui: { tab: "appearance", label: "Block Images", description: "Prevent images from being sent to LLM providers" },
 	},
 
+	"media.autoplay": {
+		type: "boolean",
+		default: true,
+		ui: { tab: "appearance", label: "Autoplay Media", description: "Play rich media once when it becomes visible" },
+	},
+
+	"media.reducedMotion": {
+		type: "boolean",
+		default: false,
+		ui: { tab: "appearance", label: "Reduced Motion", description: "Disable automatic rich-media playback" },
+	},
+
+	"media.fpsCap": {
+		type: "number",
+		default: 12,
+		ui: { tab: "appearance", label: "Media FPS Cap", description: "Maximum rich-media playback frame rate" },
+	},
+
 	"images.pasteDir": {
 		type: "string",
 		default: ".",

package/src/internal-urls/build-info.generated.ts

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "20.15.2",
-	"commit": "1acb1e762fd2e2e9f403ae83cab293e9280a71de",
-	"shortCommit": "1acb1e7",
+	"version": "20.16.0",
+	"commit": "5c1d6f26773e45cf387e740af8c7f17bc8088b33",
+	"shortCommit": "5c1d6f2",
 	"branch": "main",
-	"tag": "v20.15.2",
-	"commitDate": "2026-08-13T23:35:16Z",
-	"buildDate": "2026-08-13T23:58:59.501Z",
+	"tag": "v20.16.0",
+	"commitDate": "2026-08-15T05:11:57Z",
+	"buildDate": "2026-08-15T05:38:17.354Z",
 	"dirty": true,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5-sales-demo/xcsh",
 	"repoSlug": "f5-sales-demo/xcsh",
-	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/1acb1e762fd2e2e9f403ae83cab293e9280a71de",
-	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v20.15.2"
+	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/5c1d6f26773e45cf387e740af8c7f17bc8088b33",
+	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v20.16.0"
 };

package/src/internal-urls/console-catalog.generated.ts

@@ -2,10 +2,10 @@
 
 import type { ConsoleCatalogData } from "./console-catalog-types";
 
-export const CONSOLE_CATALOG_VERSION = "8b9b10a8d85e70ddbb46cce584fcaa5fdf2b12c3";
+export const CONSOLE_CATALOG_VERSION = "189c19b1401c9b97008fc0638b96c5805bfb3c62";
 
 export const CONSOLE_CATALOG_DATA: ConsoleCatalogData = {
-	version: "8b9b10a8d85e70ddbb46cce584fcaa5fdf2b12c3",
+	version: "189c19b1401c9b97008fc0638b96c5805bfb3c62",
 	workflows: {
 		"address-allocator/create":
 			'---\nschema: urn:xcsh:console:workflow:v1\nid: address-allocator-create\nlabel: Create IP Address Allocators\nresource: address-allocator\noperation: create\npreconditions:\n  - user_logged_in\n  - "role_minimum: admin"\nparams:\n  name:\n    required: true\n    description: IP Address Allocators name (lowercase alphanumeric and hyphens)\n    example: example-address-allocator\n  address_allocator_mode:\n    required: true\n    description: Address Allocator Mode\n  allocation_unit:\n    required: false\n    description: Allocation Unit\n    default: 0\n  address_pool:\n    required: false\n    description: Address Pool\n    default: value\n  address_allocation_scheme:\n    required: false\n    description: "Server-required: Field should be not nil"\n    default: value\nsteps:\n  - id: navigate-to-list\n    action: navigate\n    url: /web/workspaces/multi-cloud-network-connect/manage/networking/legacy_network_configuration/address_allocators\n    wait_for: text(\'IP Address Allocators\')\n    description: Navigate to IP Address Allocators list page\n  - id: click-add-tab\n    action: click\n    selector: text(\'Add IP Address Allocator\')\n    wait_for: textbox[name=\'Name\']\n    description: Click Add IP Address Allocator to open the create form\n  - id: fill-name\n    action: fill\n    selector: textbox[name=\'Name\']\n    value: "{name}"\n    description: Enter Name\n  - id: select-address_allocator_mode\n    action: select\n    selector: listbox\n    context: Address Allocator Mode section\n    value: "{address_allocator_mode}"\n    description: Select Address Allocator Mode\n  - id: fill-allocation_unit\n    action: fill\n    selector: spinbutton[name=\'Allocation Unit\']\n    value: "{allocation_unit}"\n    description: Set Allocation Unit\n  - id: fill-address_pool\n    action: fill\n    selector: ngx-datatable input.form-control\n    context: Address Pool table\n    value: "{address_pool}"\n    description: Enter Address Pool in the existing table row (no Add Item needed — the table ships one empty row)\n  - id: select-address_allocation_scheme\n    action: select\n    selector: listbox\n    context: Address Allocation Scheme section\n    value: "{address_allocation_scheme}"\n    description: Select Address Allocation Scheme\n  - id: save\n    action: click\n    selector: "[class*=\'save-bt\'],[class*=\'submit-button\']"\n    context: footer\n    wait_for: text(\'{name}\')\n    wait_timeout_ms: 30000\n    description: Save/submit the form (union selector matches save-bt OR submit-button)\npostconditions:\n  - resource_list_page_visible\n  - "resource_name_in_list: {name}"\nmetadata:\n  confidence: inferred\n  discovered_at: 2026-06-24\n  console_version: "2025.06"\n  notes: Auto-generated by scripts/generate-workflows.ts from api-specs-enriched field metadata.\n',

package/src/media/ffmpeg.ts

@@ -0,0 +1,399 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export interface ProbedMedia {
+	width?: number;
+	height?: number;
+	durationMs?: number;
+}
+
+export interface DecodedRasterFrame {
+	data: Buffer;
+	durationMs: number;
+}
+
+export interface DecodeRasterFramesOptions {
+	ffmpegPath?: string;
+	fpsCap?: number;
+	maxFrames?: number;
+	maxOutputBytes?: number;
+	timeoutMs?: number;
+	signal?: AbortSignal;
+	webpmuxPath?: string;
+	animDumpPath?: string;
+}
+
+async function runWithInput(
+	command: string[],
+	input: Buffer,
+	timeoutMs: number,
+	maxOutputBytes: number,
+	signal?: AbortSignal,
+): Promise<Buffer> {
+	const child = Bun.spawn(command, { stdin: "pipe", stdout: "pipe", stderr: "pipe" });
+	let timedOut = false;
+	let aborted = false;
+	const onAbort = () => {
+		aborted = true;
+		child.kill();
+	};
+	signal?.addEventListener("abort", onAbort, { once: true });
+	if (signal?.aborted) onAbort();
+	const timer = setTimeout(() => {
+		timedOut = true;
+		child.kill();
+	}, timeoutMs);
+	const stderrPromise = new Response(child.stderr).text();
+	const chunks: Buffer[] = [];
+	let bytes = 0;
+	try {
+		child.stdin.write(input);
+		child.stdin.end();
+		const reader = child.stdout.getReader();
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			const chunk = Buffer.from(value);
+			bytes += chunk.byteLength;
+			if (bytes > maxOutputBytes) {
+				child.kill();
+				throw new Error("decoded media output exceeded its bound");
+			}
+			chunks.push(chunk);
+		}
+		const exitCode = await child.exited;
+		const stderr = await stderrPromise;
+		if (aborted) throw signal?.reason ?? new Error("media decoder aborted");
+		if (timedOut) throw new Error("media decoder timed out");
+		if (exitCode !== 0) throw new Error(stderr.trim() || `${command[0]} exited with code ${exitCode}`);
+		return Buffer.concat(chunks, bytes);
+	} finally {
+		clearTimeout(timer);
+		signal?.removeEventListener("abort", onAbort);
+	}
+}
+
+async function runWithoutInput(
+	command: string[],
+	timeoutMs: number,
+	maxOutputBytes: number,
+	signal?: AbortSignal,
+): Promise<Buffer> {
+	const child = Bun.spawn(command, { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+	let timedOut = false;
+	let aborted = false;
+	const onAbort = () => {
+		aborted = true;
+		child.kill();
+	};
+	signal?.addEventListener("abort", onAbort, { once: true });
+	if (signal?.aborted) onAbort();
+	const timer = setTimeout(() => {
+		timedOut = true;
+		child.kill();
+	}, timeoutMs);
+	const stderrPromise = new Response(child.stderr).text();
+	const chunks: Buffer[] = [];
+	let bytes = 0;
+	try {
+		const reader = child.stdout.getReader();
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			const chunk = Buffer.from(value);
+			bytes += chunk.byteLength;
+			if (bytes > maxOutputBytes) {
+				child.kill();
+				throw new Error("media helper output exceeded its bound");
+			}
+			chunks.push(chunk);
+		}
+		const exitCode = await child.exited;
+		const stderr = await stderrPromise;
+		if (aborted) throw signal?.reason ?? new Error("media helper aborted");
+		if (timedOut) throw new Error("media helper timed out");
+		if (exitCode !== 0) throw new Error(stderr.trim() || `${command[0]} exited with code ${exitCode}`);
+		return Buffer.concat(chunks, bytes);
+	} finally {
+		clearTimeout(timer);
+		signal?.removeEventListener("abort", onAbort);
+	}
+}
+
+function isAnimatedWebp(input: Buffer): boolean {
+	return (
+		input.length >= 16 &&
+		input.subarray(0, 4).toString("ascii") === "RIFF" &&
+		input.subarray(8, 12).toString("ascii") === "WEBP" &&
+		input.includes(Buffer.from("ANIM"))
+	);
+}
+
+async function decodeAnimatedWebpFallback(
+	input: Buffer,
+	options: {
+		ffmpegPath: string;
+		webpmuxPath: string;
+		animDumpPath: string;
+		maxFrames: number;
+		maxOutputBytes: number;
+		timeoutMs: number;
+		fpsCap: number;
+		signal?: AbortSignal;
+	},
+): Promise<DecodedRasterFrame[] | null> {
+	const directory = await fs.mkdtemp(path.join(os.tmpdir(), "xcsh-webp-"));
+	try {
+		const sourcePath = path.join(directory, "input.webp");
+		const framesPath = path.join(directory, "frames");
+		await fs.mkdir(framesPath);
+		await fs.writeFile(sourcePath, input);
+		const info = (
+			await runWithoutInput(
+				[options.webpmuxPath, "-info", sourcePath],
+				options.timeoutMs,
+				1024 * 1024,
+				options.signal,
+			)
+		).toString("utf8");
+		const canvas = /Canvas size:\s*(\d+)\s*x\s*(\d+)/u.exec(info);
+		const count = /Number of frames:\s*(\d+)/u.exec(info);
+		const width = Number(canvas?.[1]);
+		const height = Number(canvas?.[2]);
+		const frameCount = Number(count?.[1]);
+		if (
+			!Number.isInteger(width) ||
+			!Number.isInteger(height) ||
+			!Number.isInteger(frameCount) ||
+			width <= 0 ||
+			height <= 0 ||
+			frameCount <= 0 ||
+			frameCount > options.maxFrames ||
+			width * height * 4 * frameCount > options.maxOutputBytes
+		) {
+			return null;
+		}
+		const nativeDurations = info
+			.split("\n")
+			.map(line => /^\s*\d+:\s+\d+\s+\d+\s+\S+\s+\d+\s+\d+\s+(\d+)/u.exec(line))
+			.filter((match): match is RegExpExecArray => match !== null)
+			.map(match => Number(match[1]));
+		await runWithoutInput(
+			[options.animDumpPath, "-folder", framesPath, "-prefix", "frame_", "-pam", sourcePath],
+			options.timeoutMs,
+			1024 * 1024,
+			options.signal,
+		);
+		const framePaths = (await fs.readdir(framesPath))
+			.filter(name => /^frame_\d+\.pam$/u.test(name))
+			.sort(
+				(left, right) =>
+					Number(left.slice("frame_".length, -".pam".length)) -
+					Number(right.slice("frame_".length, -".pam".length)),
+			)
+			.slice(0, options.maxFrames);
+		if (framePaths.length !== frameCount) return null;
+		const frames: DecodedRasterFrame[] = [];
+		let outputBytes = 0;
+		const minimumDuration = Math.ceil(1000 / options.fpsCap);
+		for (const [index, name] of framePaths.entries()) {
+			const pam = await fs.readFile(path.join(framesPath, name));
+			const remaining = options.maxOutputBytes - outputBytes;
+			if (remaining <= 0) return null;
+			const png = await runWithInput(
+				[
+					options.ffmpegPath,
+					"-v",
+					"error",
+					"-nostdin",
+					"-f",
+					"image2pipe",
+					"-vcodec",
+					"pam",
+					"-i",
+					"pipe:0",
+					"-frames:v",
+					"1",
+					"-f",
+					"image2pipe",
+					"-vcodec",
+					"png",
+					"pipe:1",
+				],
+				pam,
+				options.timeoutMs,
+				remaining,
+				options.signal,
+			);
+			outputBytes += png.byteLength;
+			frames.push({ data: png, durationMs: Math.max(minimumDuration, nativeDurations[index] ?? minimumDuration) });
+		}
+		return frames;
+	} catch {
+		return null;
+	} finally {
+		await fs.rm(directory, { recursive: true, force: true });
+	}
+}
+
+function splitPngStream(output: Buffer, maxFrames: number): Buffer[] {
+	const signature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+	const frames: Buffer[] = [];
+	let offset = 0;
+	while (offset < output.length) {
+		if (!output.subarray(offset, offset + signature.length).equals(signature)) {
+			throw new Error("FFmpeg emitted an invalid PNG stream");
+		}
+		const start = offset;
+		offset += signature.length;
+		let complete = false;
+		while (offset + 12 <= output.length) {
+			const length = output.readUInt32BE(offset);
+			const chunkEnd = offset + 12 + length;
+			if (chunkEnd > output.length) throw new Error("FFmpeg emitted a truncated PNG frame");
+			const type = output.subarray(offset + 4, offset + 8).toString("ascii");
+			offset = chunkEnd;
+			if (type === "IEND") {
+				frames.push(output.subarray(start, offset));
+				if (frames.length > maxFrames) throw new Error("decoded media exceeded its frame bound");
+				complete = true;
+				break;
+			}
+		}
+		if (!complete) throw new Error("FFmpeg emitted an incomplete PNG frame");
+	}
+	return frames;
+}
+
+export async function probeMedia(
+	input: Buffer,
+	ffprobePath = "ffprobe",
+	timeoutMs = 10_000,
+	signal?: AbortSignal,
+): Promise<ProbedMedia | null> {
+	try {
+		const output = await runWithInput(
+			[
+				ffprobePath,
+				"-v",
+				"error",
+				"-select_streams",
+				"v:0",
+				"-show_entries",
+				"stream=width,height:format=duration",
+				"-of",
+				"json",
+				"-i",
+				"pipe:0",
+			],
+			input,
+			timeoutMs,
+			1024 * 1024,
+			signal,
+		);
+		const parsed = JSON.parse(output.toString("utf8")) as {
+			streams?: Array<{ width?: number; height?: number }>;
+			format?: { duration?: string };
+		};
+		const stream = parsed.streams?.[0];
+		const durationSeconds = Number(parsed.format?.duration);
+		return {
+			width: stream?.width,
+			height: stream?.height,
+			durationMs:
+				Number.isFinite(durationSeconds) && durationSeconds > 0 ? Math.round(durationSeconds * 1000) : undefined,
+		};
+	} catch {
+		return null;
+	}
+}
+
+export async function decodePoster(
+	input: Buffer,
+	ffmpegPath = "ffmpeg",
+	timeoutMs = 15_000,
+	signal?: AbortSignal,
+): Promise<Buffer | null> {
+	try {
+		return await runWithInput(
+			[
+				ffmpegPath,
+				"-v",
+				"error",
+				"-nostdin",
+				"-i",
+				"pipe:0",
+				"-an",
+				"-frames:v",
+				"1",
+				"-vf",
+				"scale='min(1920,iw)':-2",
+				"-f",
+				"image2pipe",
+				"-vcodec",
+				"png",
+				"pipe:1",
+			],
+			input,
+			timeoutMs,
+			25 * 1024 * 1024,
+			signal,
+		);
+	} catch {
+		return null;
+	}
+}
+
+export async function decodeRasterFrames(
+	input: Buffer,
+	options: DecodeRasterFramesOptions = {},
+): Promise<DecodedRasterFrame[] | null> {
+	const ffmpegPath = options.ffmpegPath ?? "ffmpeg";
+	const fpsCap = Math.max(1, Math.min(60, Math.floor(options.fpsCap ?? 12)));
+	const maxFrames = Math.max(1, Math.floor(options.maxFrames ?? 720));
+	const maxOutputBytes = Math.max(1, Math.floor(options.maxOutputBytes ?? 100 * 1024 * 1024));
+	const timeoutMs = Math.max(1, Math.floor(options.timeoutMs ?? 30_000));
+	try {
+		const output = await runWithInput(
+			[
+				ffmpegPath,
+				"-v",
+				"error",
+				"-nostdin",
+				"-i",
+				"pipe:0",
+				"-an",
+				"-vf",
+				`fps=${fpsCap},scale='min(1920,iw)':-2`,
+				"-frames:v",
+				String(maxFrames),
+				"-f",
+				"image2pipe",
+				"-vcodec",
+				"png",
+				"pipe:1",
+			],
+			input,
+			timeoutMs,
+			maxOutputBytes,
+			options.signal,
+		);
+		const durationMs = Math.ceil(1000 / fpsCap);
+		const frames = splitPngStream(output, maxFrames);
+		if (frames.length === 0) return null;
+		return frames.map(data => ({ data, durationMs }));
+	} catch {
+		if (!isAnimatedWebp(input)) return null;
+		return await decodeAnimatedWebpFallback(input, {
+			ffmpegPath,
+			webpmuxPath: options.webpmuxPath ?? "webpmux",
+			animDumpPath: options.animDumpPath ?? "anim_dump",
+			maxFrames,
+			maxOutputBytes,
+			timeoutMs,
+			fpsCap,
+			signal: options.signal,
+		});
+	}
+}