@f5-sales-demo/xcsh 19.51.2

package/src/tools/action-renderer.ts

@@ -0,0 +1,198 @@
+/** TUI renderer for lightweight action tools — checkpoint, rewind, cancel_job, poll. */
+import type { Component } from "@f5xc-salesdemos/pi-tui";
+import { Text } from "@f5xc-salesdemos/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme, ThemeColor } from "../modes/theme/theme";
+import { CachedOutputBlock, F5_TOOL_BORDER_COLOR, renderStatusLine } from "../tui";
+import type { CancelJobToolDetails } from "./cancel-job";
+import type { CheckpointToolDetails, RewindToolDetails } from "./checkpoint";
+import type { PollToolDetails } from "./poll-tool";
+import { addSection, formatErrorMessage, replaceTabs } from "./render-utils";
+
+type ActionDetails = CheckpointToolDetails | RewindToolDetails | CancelJobToolDetails | PollToolDetails;
+
+type ActionRenderArgs = {
+	goal?: string;
+	report?: string;
+	job_id?: string;
+	jobs?: string[];
+};
+
+const CANCEL_STATUS_COLORS: Record<string, ThemeColor> = {
+	cancelled: "success",
+	not_found: "warning",
+	already_completed: "dim",
+};
+
+const POLL_STATUS_COLORS: Record<string, ThemeColor> = {
+	completed: "success",
+	failed: "error",
+	running: "chromeAccent",
+	cancelled: "warning",
+};
+
+function formatDuration(ms: number): string {
+	if (ms < 1_000) return `${ms}ms`;
+	const seconds = Math.floor(ms / 1_000);
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	const remainingSeconds = seconds % 60;
+	return `${minutes}m${remainingSeconds}s`;
+}
+
+function isCheckpointDetails(d: ActionDetails): d is CheckpointToolDetails {
+	return "goal" in d && "startedAt" in d;
+}
+
+function isRewindDetails(d: ActionDetails): d is RewindToolDetails {
+	return "report" in d && "rewound" in d;
+}
+
+function isCancelJobDetails(d: ActionDetails): d is CancelJobToolDetails {
+	return "status" in d && "jobId" in d;
+}
+
+function isPollDetails(d: ActionDetails): d is PollToolDetails {
+	return "jobs" in d && Array.isArray((d as PollToolDetails).jobs);
+}
+
+function buildPollJobTable(details: PollToolDetails, uiTheme: Theme): string[] {
+	const jobs = details.jobs;
+	if (jobs.length === 0) return [uiTheme.fg("dim", "  No jobs.")];
+
+	return jobs.map(job => {
+		const statusColor = POLL_STATUS_COLORS[job.status] ?? "muted";
+		const status = uiTheme.fg(statusColor, job.status.padEnd(10));
+		const id = uiTheme.fg("toolOutput", job.id);
+		const typeBadge = uiTheme.fg("dim", `[${job.type}]`);
+		const label = uiTheme.fg("muted", job.label.length > 50 ? `${job.label.slice(0, 47)}…` : job.label);
+		const duration = uiTheme.fg("dim", formatDuration(job.durationMs));
+		return `  ${status}  ${id} ${typeBadge}  ${label}  ${duration}`;
+	});
+}
+
+export const actionRenderer = {
+	renderCall(args: ActionRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+		let title: string;
+		let description: string | undefined;
+
+		if (args.goal !== undefined) {
+			title = "Checkpoint";
+			description = uiTheme.fg("muted", args.goal.length > 60 ? `${args.goal.slice(0, 57)}…` : args.goal);
+		} else if (args.report !== undefined) {
+			title = "Rewind";
+		} else if (args.job_id !== undefined) {
+			title = "Cancel Job";
+			description = uiTheme.fg("muted", args.job_id);
+		} else if (args.jobs !== undefined) {
+			title = "Poll";
+			description =
+				args.jobs.length > 0
+					? uiTheme.fg("muted", `${args.jobs.length} job${args.jobs.length !== 1 ? "s" : ""}`)
+					: undefined;
+		} else {
+			title = "Poll";
+		}
+
+		const text = renderStatusLine({ icon: "pending", title, description }, uiTheme);
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: ActionDetails; isError?: boolean },
+		options: RenderResultOptions,
+		uiTheme: Theme,
+		_args?: ActionRenderArgs,
+	): Component {
+		const details = result.details;
+		const isError = result.isError === true;
+
+		if (isError || !details) {
+			const errorText = result.content?.find(c => c.type === "text")?.text;
+			return new Text(formatErrorMessage(errorText, uiTheme), 0, 0);
+		}
+
+		const sections: Array<{ label?: string; lines: string[] }> = [];
+		const meta: string[] = [];
+		let title: string;
+		let badgeLabel: string;
+		let badgeColor: ThemeColor;
+
+		if (isCheckpointDetails(details)) {
+			title = "Checkpoint";
+			badgeLabel = "created";
+			badgeColor = "chromeAccent";
+			addSection(sections, "Goal", [uiTheme.fg("toolOutput", `  ${details.goal}`)], uiTheme);
+		} else if (isRewindDetails(details)) {
+			title = "Rewind";
+			badgeLabel = details.rewound ? "rewound" : "no-op";
+			badgeColor = details.rewound ? "warning" : "dim";
+			addSection(
+				sections,
+				"Report",
+				details.report.split("\n").map(line => replaceTabs(uiTheme.fg("toolOutput", `  ${line}`))),
+				uiTheme,
+			);
+		} else if (isCancelJobDetails(details)) {
+			title = "Cancel Job";
+			badgeLabel = details.status;
+			badgeColor = CANCEL_STATUS_COLORS[details.status] ?? "muted";
+			meta.push(uiTheme.fg("dim", details.jobId));
+			const text = result.content?.find(c => c.type === "text")?.text ?? "";
+			addSection(sections, "Result", [uiTheme.fg("toolOutput", `  ${text}`)], uiTheme);
+		} else if (isPollDetails(details)) {
+			title = "Poll";
+			const completed = details.jobs.filter(j => j.status !== "running");
+			const running = details.jobs.filter(j => j.status === "running");
+			badgeLabel = `${details.jobs.length} job${details.jobs.length !== 1 ? "s" : ""}`;
+			badgeColor = running.length > 0 ? "chromeAccent" : "success";
+			if (completed.length > 0) meta.push(uiTheme.fg("success", `${completed.length} done`));
+			if (running.length > 0) meta.push(uiTheme.fg("chromeAccent", `${running.length} running`));
+			addSection(sections, "Jobs", buildPollJobTable(details, uiTheme), uiTheme);
+			for (const job of completed) {
+				if (job.resultText) {
+					const outputLines = job.resultText.split("\n").map(line => replaceTabs(uiTheme.fg("toolOutput", line)));
+					addSection(sections, `Output: ${job.id}`, outputLines, uiTheme, 30);
+				}
+				if (job.errorText) {
+					addSection(sections, `Error: ${job.id}`, [uiTheme.fg("error", job.errorText)], uiTheme);
+				}
+			}
+		} else {
+			title = "Action";
+			badgeLabel = "done";
+			badgeColor = "muted";
+			const text = result.content?.find(c => c.type === "text")?.text ?? "";
+			addSection(
+				sections,
+				"Result",
+				text.split("\n").map(line => replaceTabs(uiTheme.fg("toolOutput", line))),
+				uiTheme,
+			);
+		}
+
+		const header = renderStatusLine(
+			{
+				title,
+				titleColor: "muted",
+				badge: { label: badgeLabel, color: badgeColor },
+				meta: meta.length > 0 ? meta : undefined,
+			},
+			uiTheme,
+		);
+
+		const outputBlock = new CachedOutputBlock();
+		return {
+			render(width: number): string[] {
+				const state = options.isPartial ? "pending" : "success";
+				return outputBlock.render({ header, state, sections, width, borderColor: F5_TOOL_BORDER_COLOR }, uiTheme);
+			},
+			invalidate() {
+				outputBlock.invalidate();
+			},
+		};
+	},
+
+	mergeCallAndResult: true,
+	inline: true,
+};

package/src/tools/archive-reader.ts

@@ -0,0 +1,315 @@
+import { unzipSync } from "fflate";
+import { ToolError } from "./tool-errors";
+
+export type ArchiveFormat = "zip" | "tar" | "tar.gz";
+
+export interface ArchivePathCandidate {
+	archivePath: string;
+	subPath: string;
+}
+
+export interface ArchiveNode {
+	path: string;
+	isDirectory: boolean;
+	size: number;
+	mtimeMs?: number;
+}
+
+export interface ArchiveDirectoryEntry extends ArchiveNode {
+	name: string;
+}
+
+export interface ExtractedArchiveFile extends ArchiveNode {
+	bytes: Uint8Array;
+}
+
+interface TarStorage {
+	type: "tar";
+	file: File;
+}
+
+interface ZipStorage {
+	type: "zip";
+	bytes: Uint8Array;
+}
+
+type EntryStorage = TarStorage | ZipStorage;
+
+interface ArchiveIndexEntry extends ArchiveNode {
+	storage?: EntryStorage;
+}
+
+function normalizeArchiveLookupPath(rawPath?: string): string | undefined {
+	if (!rawPath) return "";
+
+	const parts = rawPath.replace(/\\/g, "/").split("/");
+	const normalizedParts: string[] = [];
+	for (const part of parts) {
+		if (!part || part === ".") continue;
+		if (part === "..") return undefined;
+		normalizedParts.push(part);
+	}
+
+	return normalizedParts.join("/");
+}
+
+function normalizeArchiveEntryPath(rawPath: string): string | undefined {
+	const parts = rawPath.replace(/\\/g, "/").split("/");
+	const normalizedParts: string[] = [];
+	for (const part of parts) {
+		if (!part || part === ".") continue;
+		if (part === "..") return undefined;
+		normalizedParts.push(part);
+	}
+
+	if (normalizedParts.length === 0) return undefined;
+	return normalizedParts.join("/");
+}
+
+function isArchiveDirectoryName(rawPath: string): boolean {
+	return rawPath.endsWith("/") || rawPath.endsWith("\\");
+}
+
+function upsertArchiveEntry(map: Map<string, ArchiveIndexEntry>, entry: ArchiveIndexEntry): void {
+	const existing = map.get(entry.path);
+	if (!existing) {
+		map.set(entry.path, entry);
+		return;
+	}
+
+	if (existing.isDirectory && !entry.isDirectory) {
+		map.set(entry.path, entry);
+		return;
+	}
+
+	if (!existing.isDirectory && entry.isDirectory) {
+		return;
+	}
+
+	map.set(entry.path, {
+		...existing,
+		size: existing.size || entry.size,
+		mtimeMs: existing.mtimeMs ?? entry.mtimeMs,
+		storage: existing.storage ?? entry.storage,
+	});
+}
+
+function ensureParentDirectories(map: Map<string, ArchiveIndexEntry>): void {
+	for (const entry of [...map.values()]) {
+		const parts = entry.path.split("/");
+		const stop = parts.length - 1;
+		for (let index = 1; index <= stop; index++) {
+			const dirPath = parts.slice(0, index).join("/");
+			if (!dirPath || map.has(dirPath)) continue;
+			map.set(dirPath, {
+				path: dirPath,
+				isDirectory: true,
+				size: 0,
+			});
+		}
+	}
+}
+
+function getArchiveFormatFromPath(filePath: string): ArchiveFormat | undefined {
+	const normalized = filePath.toLowerCase();
+	if (normalized.endsWith(".tar.gz") || normalized.endsWith(".tgz")) return "tar.gz";
+	if (normalized.endsWith(".tar")) return "tar";
+	if (normalized.endsWith(".zip")) return "zip";
+	return undefined;
+}
+
+async function readTarEntries(bytes: Uint8Array): Promise<ArchiveIndexEntry[]> {
+	let archive: Bun.Archive;
+	try {
+		archive = new Bun.Archive(bytes);
+	} catch (error) {
+		throw new ToolError(error instanceof Error ? error.message : String(error));
+	}
+
+	let files: Map<string, File>;
+	try {
+		files = await archive.files();
+	} catch (error) {
+		throw new ToolError(error instanceof Error ? error.message : String(error));
+	}
+
+	const entries: ArchiveIndexEntry[] = [];
+	for (const [rawPath, file] of files) {
+		const normalizedPath = normalizeArchiveEntryPath(rawPath);
+		if (!normalizedPath) continue;
+		const mtimeMs = file.lastModified > 0 ? file.lastModified : undefined;
+		entries.push({
+			path: normalizedPath,
+			isDirectory: false,
+			size: file.size,
+			mtimeMs,
+			storage: { type: "tar", file },
+		});
+	}
+
+	return entries;
+}
+
+function readZipEntries(bytes: Uint8Array): ArchiveIndexEntry[] {
+	let files: Record<string, Uint8Array>;
+	try {
+		files = unzipSync(bytes);
+	} catch (error) {
+		throw new ToolError(error instanceof Error ? error.message : String(error));
+	}
+
+	const entries: ArchiveIndexEntry[] = [];
+	for (const [rawPath, fileBytes] of Object.entries(files)) {
+		const normalizedPath = normalizeArchiveEntryPath(rawPath);
+		if (!normalizedPath) continue;
+		const isDirectory = isArchiveDirectoryName(rawPath);
+		entries.push({
+			path: normalizedPath,
+			isDirectory,
+			size: isDirectory ? 0 : fileBytes.byteLength,
+			storage: isDirectory ? undefined : { type: "zip", bytes: fileBytes },
+		});
+	}
+
+	return entries;
+}
+
+export function parseArchivePathCandidates(filePath: string): ArchivePathCandidate[] {
+	const normalized = filePath.replace(/\\/g, "/");
+	const pattern = /\.(?:tar\.gz|tgz|zip|tar)(?=(?::|$))/gi;
+	const seen = new Set<string>();
+	const candidates: ArchivePathCandidate[] = [];
+
+	let match: RegExpExecArray | null;
+	while (true) {
+		match = pattern.exec(normalized);
+		if (match === null) {
+			break;
+		}
+		const end = match.index + match[0].length;
+		const archivePath = filePath.slice(0, end);
+		const subPath = normalized.slice(end).replace(/^:+/, "");
+		const key = `${archivePath}\0${subPath}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		candidates.push({ archivePath, subPath });
+	}
+
+	return candidates.sort((left, right) => right.archivePath.length - left.archivePath.length);
+}
+
+export class ArchiveReader {
+	readonly format: ArchiveFormat;
+	#entries = new Map<string, ArchiveIndexEntry>();
+
+	constructor(format: ArchiveFormat, entries: ArchiveIndexEntry[]) {
+		this.format = format;
+		for (const entry of entries) {
+			upsertArchiveEntry(this.#entries, entry);
+		}
+		ensureParentDirectories(this.#entries);
+	}
+
+	getNode(subPath?: string): ArchiveNode | undefined {
+		const normalizedPath = normalizeArchiveLookupPath(subPath);
+		if (normalizedPath === undefined) return undefined;
+		if (normalizedPath === "") {
+			return { path: "", isDirectory: true, size: 0 };
+		}
+
+		const entry = this.#entries.get(normalizedPath);
+		if (!entry) return undefined;
+		return {
+			path: entry.path,
+			isDirectory: entry.isDirectory,
+			size: entry.size,
+			mtimeMs: entry.mtimeMs,
+		};
+	}
+
+	listDirectory(subPath?: string): ArchiveDirectoryEntry[] {
+		const normalizedPath = normalizeArchiveLookupPath(subPath);
+		if (normalizedPath === undefined) {
+			throw new ToolError("Archive path cannot contain '..'");
+		}
+
+		if (normalizedPath) {
+			const entry = this.#entries.get(normalizedPath);
+			if (!entry) {
+				throw new ToolError(`Archive path '${normalizedPath}' not found`);
+			}
+			if (!entry.isDirectory) {
+				throw new ToolError(`Archive path '${normalizedPath}' is not a directory`);
+			}
+		}
+
+		const prefix = normalizedPath ? `${normalizedPath}/` : "";
+		const children = new Map<string, ArchiveDirectoryEntry>();
+
+		for (const entry of this.#entries.values()) {
+			if (normalizedPath) {
+				if (!entry.path.startsWith(prefix) || entry.path === normalizedPath) continue;
+			}
+
+			const relativePath = normalizedPath ? entry.path.slice(prefix.length) : entry.path;
+			const nextSegment = relativePath.split("/")[0];
+			if (!nextSegment) continue;
+
+			const childPath = normalizedPath ? `${normalizedPath}/${nextSegment}` : nextSegment;
+			if (children.has(childPath)) continue;
+
+			const childEntry = this.#entries.get(childPath);
+			const isDirectory = childEntry?.isDirectory ?? relativePath.includes("/");
+			children.set(childPath, {
+				name: nextSegment,
+				path: childPath,
+				isDirectory,
+				size: isDirectory ? 0 : (childEntry?.size ?? entry.size),
+				mtimeMs: childEntry?.mtimeMs ?? entry.mtimeMs,
+			});
+		}
+
+		return [...children.values()].sort((left, right) =>
+			left.name.toLowerCase().localeCompare(right.name.toLowerCase()),
+		);
+	}
+
+	async readFile(subPath: string): Promise<ExtractedArchiveFile> {
+		const normalizedPath = normalizeArchiveLookupPath(subPath);
+		if (!normalizedPath) {
+			throw new ToolError("Archive file path is required");
+		}
+
+		const entry = this.#entries.get(normalizedPath);
+		if (!entry) {
+			throw new ToolError(`Archive file '${normalizedPath}' not found`);
+		}
+		if (entry.isDirectory) {
+			throw new ToolError(`Archive path '${normalizedPath}' is a directory`);
+		}
+		if (!entry.storage) {
+			throw new ToolError(`Archive file '${normalizedPath}' has no readable storage`);
+		}
+
+		const bytes = entry.storage.type === "tar" ? await entry.storage.file.bytes() : entry.storage.bytes;
+
+		return {
+			path: entry.path,
+			isDirectory: false,
+			size: entry.size,
+			mtimeMs: entry.mtimeMs,
+			bytes,
+		};
+	}
+}
+
+export async function openArchive(filePath: string): Promise<ArchiveReader> {
+	const format = getArchiveFormatFromPath(filePath);
+	if (!format) {
+		throw new ToolError(`Unsupported archive format: ${filePath}`);
+	}
+
+	const bytes = await Bun.file(filePath).bytes();
+	const entries = format === "zip" ? readZipEntries(bytes) : await readTarEntries(bytes);
+	return new ArchiveReader(format, entries);
+}