@f5-sales-demo/xcsh 19.51.2

package/src/slash-commands/export-command.ts

@@ -0,0 +1,178 @@
+import type { AutocompleteItem } from "@f5xc-salesdemos/pi-tui";
+import type { InteractiveModeContext } from "../modes/types";
+
+interface ParsedBuiltinSlashCommand {
+	name: string;
+	args: string;
+	text: string;
+}
+
+function getExportKindCompletions(prefix: string): AutocompleteItem[] | null {
+	try {
+		const { kindResolver } = require("../resource-management/index") as typeof import("../resource-management/index");
+		const kinds = kindResolver.getKindsWithApiPaths();
+		const lower = prefix.toLowerCase();
+		const items = kinds
+			.filter(k => k.toLowerCase().startsWith(lower))
+			.slice(0, 20)
+			.map(k => ({ value: `${k} `, label: k }));
+		return items.length > 0 ? items : null;
+	} catch {
+		return null;
+	}
+}
+
+export async function handleExportResourceCommand(
+	command: ParsedBuiltinSlashCommand,
+	ctx: InteractiveModeContext,
+): Promise<void> {
+	ctx.editor.addToHistory(command.text);
+	ctx.editor.setText("");
+
+	const {
+		parseExportArgs,
+		ResourceClient,
+		KindResolutionError,
+		toManifest,
+		formatManifestOutput,
+		buildMinimalExportFilter,
+		applyMinimalExportFilter,
+	} = await import("@f5xc-salesdemos/pi-resource-management");
+	const { kindResolver } = await import("../resource-management/index");
+
+	const parsed = parseExportArgs(command.args);
+	if ("error" in parsed) {
+		ctx.showStatus(parsed.error);
+		return;
+	}
+
+	const { ContextService } = await import("../services/xcsh-context");
+	const { createContextEnv } = await import("../services/context-env");
+	const { settings } = await import("../config/settings");
+
+	let svc: typeof ContextService.prototype;
+	try {
+		svc = ContextService.instance;
+	} catch {
+		ctx.showStatus("No F5 XC context active. Run /context create to configure one first.");
+		return;
+	}
+
+	const status = svc.getStatus();
+	if (!status.isConfigured) {
+		ctx.showStatus("No F5 XC context active. Run /context create to configure one first.");
+		return;
+	}
+
+	const contextEnv = createContextEnv(settings);
+	const apiUrl = contextEnv.get("XCSH_API_URL");
+	const apiToken = contextEnv.get("XCSH_API_TOKEN");
+	const defaultNamespace = contextEnv.get("XCSH_NAMESPACE") ?? "";
+
+	if (!apiUrl || !apiToken) {
+		ctx.showStatus("Missing API credentials. Check your context configuration.");
+		return;
+	}
+
+	const ns = parsed.namespace ?? defaultNamespace;
+	const client = new ResourceClient({
+		apiUrl,
+		apiToken,
+		namespace: ns,
+	});
+
+	const fmt = parsed.outputFormat;
+
+	try {
+		const manifests: Array<{ kind: string; metadata: Record<string, unknown>; spec: Record<string, unknown> }> = [];
+
+		if (parsed.all) {
+			const result = await client.exportAll(kindResolver, ns, (kind, count) => {
+				ctx.showStatus(`Exporting ${kind} (${count} found)...`);
+			});
+
+			for (const err of result.errors) {
+				ctx.showStatus(`Warning: ${err.kind}: ${err.error.message}`);
+			}
+
+			manifests.push(...result.manifests);
+		} else if (parsed.kind && parsed.name) {
+			const resolved = kindResolver.resolveKind(parsed.kind);
+			const result = await client.exportOne(parsed.kind, resolved, parsed.name, ns);
+			if (result.error) {
+				ctx.showStatus(`Error: ${result.error.message}`);
+				return;
+			}
+			manifests.push(result.manifest!);
+		} else if (parsed.kind) {
+			const resolved = kindResolver.resolveKind(parsed.kind);
+			const getResult = await client.get(resolved, undefined, ns);
+			if (getResult.error) {
+				ctx.showStatus(`Error: ${getResult.error.message}`);
+				return;
+			}
+			if (!getResult.items || getResult.items.length === 0) {
+				ctx.showStatus(`No ${parsed.kind} resources found.`);
+				return;
+			}
+			for (const item of getResult.items) {
+				manifests.push(toManifest(item, parsed.kind));
+			}
+		}
+
+		if (manifests.length === 0) {
+			ctx.showStatus("No resources found to export.");
+			return;
+		}
+
+		// Emit only minimum (non-default) settings: strip server-applied defaults
+		// per kind. Kinds with no defaults coverage are left untouched (full spec).
+		for (const m of manifests) {
+			const filter = buildMinimalExportFilter(m.kind);
+			if (filter) {
+				m.spec = applyMinimalExportFilter(m.spec, filter);
+			}
+		}
+
+		const output = formatManifestOutput(manifests, fmt);
+
+		if (parsed.outputFile) {
+			const { writeFile, mkdir } = await import("node:fs/promises");
+			const { dirname, resolve, sep } = await import("node:path");
+			const isDir = parsed.outputFile.endsWith("/");
+
+			if (isDir) {
+				await mkdir(parsed.outputFile, { recursive: true });
+				const baseDir = resolve(parsed.outputFile);
+				const ext = fmt === "yaml" ? "yaml" : "json";
+				for (const m of manifests) {
+					const safeKind = m.kind.replace(/[/\\]/g, "_");
+					const safeName = ((m.metadata.name as string) ?? "unknown").replace(/[/\\]/g, "_");
+					const filename = `${safeKind}-${safeName}.${ext}`;
+					const filepath = resolve(parsed.outputFile, filename);
+					if (!filepath.startsWith(baseDir + sep) && filepath !== baseDir) {
+						ctx.showStatus(`Skipping unsafe resource name: ${m.metadata.name}`);
+						continue;
+					}
+					const content = formatManifestOutput([m], fmt);
+					await writeFile(filepath, content, "utf-8");
+				}
+				ctx.showStatus(`Exported ${manifests.length} resource(s) to ${parsed.outputFile}`);
+			} else {
+				await mkdir(dirname(parsed.outputFile), { recursive: true });
+				await writeFile(parsed.outputFile, output, "utf-8");
+				ctx.showStatus(`Exported ${manifests.length} resource(s) to ${parsed.outputFile}`);
+			}
+		} else {
+			ctx.showStatus(output);
+		}
+	} catch (err) {
+		if (err instanceof KindResolutionError) {
+			ctx.showStatus(`Error: ${err.message}`);
+		} else {
+			ctx.showStatus(`Unexpected error: ${(err as Error).message}`);
+		}
+	}
+}
+
+export { getExportKindCompletions };

package/src/slash-commands/marketplace-install-parser.ts

@@ -0,0 +1,99 @@
+const USAGE = "Usage: /plugin install [--force] [--scope user|project] <name@marketplace>";
+
+export interface MarketplaceInstallArgs {
+	force: boolean;
+	scope: "user" | "project";
+	installSpec: string;
+}
+
+/**
+ * Parse the argument string following `/marketplace install`.
+ *
+ * Returns either the parsed args or an `{ error }` object whose message is
+ * suitable for direct display to the user via `ctx.showStatus`.
+ *
+ * Accepted flags (any order):
+ *   --force                 Force-reinstall even if already installed
+ *   --scope user|project    Installation scope (default: user)
+ *
+ * Exactly one positional argument is required: `name@marketplace`.
+ */
+export function parseMarketplaceInstallArgs(rest: string): MarketplaceInstallArgs | { error: string } {
+	const tokens = rest.split(/\s+/).filter(Boolean);
+	let force = false;
+	let scope: "user" | "project" = "user";
+	let installSpec = "";
+
+	for (let i = 0; i < tokens.length; i++) {
+		if (tokens[i] === "--force") {
+			force = true;
+		} else if (tokens[i] === "--scope" && i + 1 < tokens.length && !tokens[i + 1].startsWith("-")) {
+			const s = tokens[++i];
+			if (s === "user" || s === "project") {
+				scope = s;
+			} else {
+				return { error: `Invalid --scope value: "${s}". Must be "user" or "project".` };
+			}
+		} else if (tokens[i] === "--scope") {
+			// --scope with no value, or next token is another flag
+			return { error: '--scope requires a value: "user" or "project".' };
+		} else if (tokens[i].startsWith("-")) {
+			return { error: `Unknown flag: "${tokens[i]}". ${USAGE}` };
+		} else {
+			if (installSpec) {
+				return { error: `Unexpected argument: "${tokens[i]}". ${USAGE}` };
+			}
+			installSpec = tokens[i];
+		}
+	}
+
+	if (!installSpec.includes("@")) {
+		return { error: USAGE };
+	}
+
+	return { force, scope, installSpec };
+}
+
+// ── Shared scope+id parser for uninstall / upgrade / enable / disable ───────
+
+export interface PluginScopeArgs {
+	pluginId: string;
+	scope?: "user" | "project";
+}
+
+/**
+ * Parse `[--scope user|project] <name@marketplace>` for commands that accept a
+ * single plugin ID and an optional scope flag.
+ *
+ * Returns parsed args or `{ error }` ready for `ctx.showStatus`.
+ */
+export function parsePluginScopeArgs(rest: string, usageHint: string): PluginScopeArgs | { error: string } {
+	const tokens = rest.split(/\s+/).filter(Boolean);
+	let scope: "user" | "project" | undefined;
+	let pluginId = "";
+
+	for (let i = 0; i < tokens.length; i++) {
+		if (tokens[i] === "--scope" && i + 1 < tokens.length && !tokens[i + 1].startsWith("-")) {
+			const s = tokens[++i];
+			if (s === "user" || s === "project") {
+				scope = s;
+			} else {
+				return { error: `Invalid --scope value: "${s}". Must be "user" or "project".` };
+			}
+		} else if (tokens[i] === "--scope") {
+			return { error: '--scope requires a value: "user" or "project".' };
+		} else if (tokens[i].startsWith("-")) {
+			return { error: `Unknown flag: "${tokens[i]}". ${usageHint}` };
+		} else if (pluginId) {
+			return { error: `Unexpected argument: "${tokens[i]}". ${usageHint}` };
+		} else {
+			pluginId = tokens[i];
+		}
+	}
+
+	if (!pluginId) {
+		return { error: usageHint };
+	}
+
+	return { pluginId, scope };
+}

package/src/slash-commands/resource-commands.ts

@@ -0,0 +1,250 @@
+import type { AutocompleteItem } from "@f5xc-salesdemos/pi-tui";
+import type { InteractiveModeContext } from "../modes/types";
+
+interface ParsedBuiltinSlashCommand {
+	name: string;
+	args: string;
+	text: string;
+}
+
+function getKindCompletions(prefix: string): AutocompleteItem[] | null {
+	try {
+		const { kindResolver } = require("../resource-management/index") as typeof import("../resource-management/index");
+		const kinds = kindResolver.getKindsWithApiPaths();
+		const lower = prefix.toLowerCase();
+		const items = kinds
+			.filter(k => k.toLowerCase().startsWith(lower))
+			.slice(0, 20)
+			.map(k => ({ value: `${k} `, label: k }));
+		return items.length > 0 ? items : null;
+	} catch {
+		return null;
+	}
+}
+
+export async function handleResourceCommand(
+	commandName: string,
+	command: ParsedBuiltinSlashCommand,
+	ctx: InteractiveModeContext,
+): Promise<void> {
+	ctx.editor.addToHistory(command.text);
+	ctx.editor.setText("");
+
+	const {
+		parseResourceArgs,
+		ResourceClient,
+		readManifestFiles,
+		ManifestFileError,
+		parseManifests,
+		ManifestParseError,
+		KindResolutionError,
+		validateManifest,
+		formatValidationErrors,
+		formatOperationResult,
+		formatResourceList,
+		formatResourceDetail,
+		formatMultiOperationSummary,
+		formatDiff,
+	} = await import("@f5xc-salesdemos/pi-resource-management");
+	const { kindResolver } = await import("../resource-management/index");
+
+	const parsed = parseResourceArgs(command.args);
+	if ("error" in parsed) {
+		ctx.showStatus(parsed.error);
+		return;
+	}
+
+	const { ContextService } = await import("../services/xcsh-context");
+	const { createContextEnv } = await import("../services/context-env");
+	const { settings } = await import("../config/settings");
+
+	let svc: typeof ContextService.prototype;
+	try {
+		svc = ContextService.instance;
+	} catch {
+		ctx.showStatus("No F5 XC context active. Run /context create to configure one first.");
+		return;
+	}
+
+	const status = svc.getStatus();
+	if (!status.isConfigured) {
+		ctx.showStatus("No F5 XC context active. Run /context create to configure one first.");
+		return;
+	}
+
+	const contextEnv = createContextEnv(settings);
+	const apiUrl = contextEnv.get("XCSH_API_URL");
+	const apiToken = contextEnv.get("XCSH_API_TOKEN");
+	const defaultNamespace = contextEnv.get("XCSH_NAMESPACE") ?? "";
+
+	if (!apiUrl || !apiToken) {
+		ctx.showStatus("Missing API credentials. Check your context configuration.");
+		return;
+	}
+
+	const client = new ResourceClient({
+		apiUrl,
+		apiToken,
+		namespace: parsed.namespace ?? defaultNamespace,
+		resolvePayloadVars: (json: string) => contextEnv.resolvePayloadVars(json),
+	});
+
+	const ns = parsed.namespace ?? defaultNamespace;
+
+	try {
+		switch (commandName) {
+			case "apply":
+			case "create": {
+				if (parsed.filenames.length === 0) {
+					ctx.showStatus(
+						`Usage: /${commandName} -f <file.json|file.yaml|dir/> [-n namespace] [--dry-run=client|server]`,
+					);
+					return;
+				}
+				const fileResults = await readManifestFiles(parsed.filenames, parsed.recursive);
+				const allObjects = fileResults.flatMap(r => r.objects);
+				if (allObjects.length === 0) {
+					ctx.showStatus("No resources found in the specified file(s).");
+					return;
+				}
+				const manifests = parseManifests(allObjects, fileResults[0]?.sourcePath ?? "input");
+				const results = [];
+				for (const manifest of manifests) {
+					const { result: valResult, resolved } = validateManifest(manifest, kindResolver, ns);
+					if (!valResult.valid) {
+						ctx.showStatus(formatValidationErrors(manifest, valResult));
+						results.push({
+							status: "error" as const,
+							error: { kind: "validation" as const, message: "Validation failed" },
+						});
+						continue;
+					}
+					if (!resolved) continue;
+
+					const opResult =
+						commandName === "apply"
+							? await client.apply(manifest, resolved, ns, parsed.dryRun)
+							: await client.create(manifest, resolved, ns, parsed.dryRun);
+
+					results.push(opResult);
+					ctx.showStatus(formatOperationResult(opResult, manifest, parsed.outputFormat));
+				}
+
+				if (manifests.length > 1) {
+					ctx.showStatus(formatMultiOperationSummary(results as any, manifests));
+				}
+				break;
+			}
+
+			case "delete": {
+				let deleteTargets: { kind: string; name: string }[] = [];
+
+				if (parsed.filenames.length > 0) {
+					const fileResults = await readManifestFiles(parsed.filenames, parsed.recursive);
+					const allObjects = fileResults.flatMap(r => r.objects);
+					const manifests = parseManifests(allObjects, fileResults[0]?.sourcePath ?? "input");
+					deleteTargets = manifests.map(m => ({ kind: m.kind, name: m.metadata.name }));
+				} else if (parsed.kind && parsed.name) {
+					deleteTargets = [{ kind: parsed.kind, name: parsed.name }];
+				} else {
+					ctx.showStatus("Usage: /delete -f <file> or /delete <kind> <name> [-n namespace] [--force]");
+					return;
+				}
+
+				for (const target of deleteTargets) {
+					const resolved = kindResolver.resolveKind(target.kind);
+					const result = await client.delete(target.kind, target.name, resolved, ns);
+					ctx.showStatus(
+						formatOperationResult(
+							result,
+							{ kind: target.kind, metadata: { name: target.name }, spec: {}, rawObject: {} } as any,
+							parsed.outputFormat,
+						),
+					);
+				}
+				break;
+			}
+
+			case "describe": {
+				if (!parsed.kind) {
+					ctx.showStatus("Usage: /describe <kind> <name> [-n namespace] [-o json|yaml]");
+					return;
+				}
+				const kind = parsed.kind;
+				const name = parsed.name;
+				if (!name) {
+					ctx.showStatus("Usage: /describe <kind> <name> [-n namespace] [-o json|yaml]");
+					return;
+				}
+				const resolved = kindResolver.resolveKind(kind);
+				const result = await client.get(resolved, name, ns);
+				if (result.error) {
+					ctx.showStatus(`Error: ${result.error.message}`);
+					return;
+				}
+				if (result.resource) {
+					ctx.showStatus(formatResourceDetail(result.resource, kind, parsed.outputFormat));
+				}
+				break;
+			}
+
+			case "diff": {
+				if (parsed.filenames.length === 0) {
+					ctx.showStatus("Usage: /diff -f <file.json|file.yaml> [-n namespace]");
+					return;
+				}
+				const fileResults = await readManifestFiles(parsed.filenames, parsed.recursive);
+				const allObjects = fileResults.flatMap(r => r.objects);
+				const manifests = parseManifests(allObjects, fileResults[0]?.sourcePath ?? "input");
+
+				for (const manifest of manifests) {
+					const { result: valResult, resolved } = validateManifest(manifest, kindResolver, ns);
+					if (!valResult.valid || !resolved) {
+						ctx.showStatus(formatValidationErrors(manifest, valResult));
+						continue;
+					}
+					const diffResult = await client.diff(manifest, resolved, ns);
+					if (diffResult.error) {
+						ctx.showStatus(`Error: ${diffResult.error.message}`);
+						continue;
+					}
+					if (diffResult.isNew) {
+						ctx.showStatus(`${manifest.kind}/${manifest.metadata.name} does not exist yet — will be created.`);
+						continue;
+					}
+					if (diffResult.diff) {
+						ctx.showStatus(formatDiff(diffResult.diff, manifest.kind, manifest.metadata.name));
+					}
+				}
+				break;
+			}
+
+			case "get": {
+				if (!parsed.kind) {
+					ctx.showStatus("Usage: /get <kind> [name] [-n namespace] [-o json|yaml|table]");
+					return;
+				}
+				const resolved = kindResolver.resolveKind(parsed.kind);
+				const result = await client.get(resolved, parsed.name, ns);
+				if (result.error) {
+					ctx.showStatus(`Error: ${result.error.message}`);
+					return;
+				}
+				if (result.items) {
+					ctx.showStatus(formatResourceList(result.items, parsed.kind, parsed.outputFormat));
+				} else if (result.resource) {
+					ctx.showStatus(formatResourceDetail(result.resource, parsed.kind, parsed.outputFormat));
+				}
+				break;
+			}
+		}
+	} catch (err) {
+		if (err instanceof ManifestFileError || err instanceof ManifestParseError || err instanceof KindResolutionError) {
+			ctx.showStatus(`Error: ${err.message}`);
+		} else {
+			ctx.showStatus(`Unexpected error: ${(err as Error).message}`);
+		}
+	}
+}
+
+export { getKindCompletions };

package/src/ssh/config-writer.ts

@@ -0,0 +1,183 @@
+/**
+ * SSH Configuration File Writer
+ *
+ * Utilities for reading/writing ssh.json files at user or project level.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isEnoent } from "@f5xc-salesdemos/pi-utils";
+
+export interface SSHHostConfig {
+	host: string;
+	username?: string;
+	port?: number;
+	keyPath?: string;
+	description?: string;
+	compat?: boolean;
+}
+
+export interface SSHConfigFile {
+	hosts?: Record<string, SSHHostConfig>;
+}
+
+/**
+ * Read an SSH config file.
+ * Returns empty config if file doesn't exist.
+ */
+export async function readSSHConfigFile(filePath: string): Promise<SSHConfigFile> {
+	try {
+		const content = await fs.promises.readFile(filePath, "utf-8");
+		const parsed = JSON.parse(content) as SSHConfigFile;
+		return parsed;
+	} catch (error) {
+		if (isEnoent(error)) {
+			// File doesn't exist, return empty config
+			return { hosts: {} };
+		}
+		if (error instanceof SyntaxError) {
+			throw new Error(`Failed to parse SSH config file ${filePath}: ${error.message}`);
+		}
+		throw error;
+	}
+}
+
+/**
+ * Write an SSH config file atomically.
+ * Creates parent directories if they don't exist.
+ */
+export async function writeSSHConfigFile(filePath: string, config: SSHConfigFile): Promise<void> {
+	// Ensure parent directory exists
+	const dir = path.dirname(filePath);
+	await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 });
+
+	// Write to temp file first (atomic write)
+	const tmpPath = `${filePath}.tmp`;
+	const content = JSON.stringify(config, null, 2);
+	await fs.promises.writeFile(tmpPath, content, { encoding: "utf-8", mode: 0o600 });
+
+	// Rename to final path (atomic on most systems)
+	await fs.promises.rename(tmpPath, filePath);
+}
+
+/**
+ * Validate host name.
+ * @returns Error message if invalid, undefined if valid
+ */
+export function validateHostName(name: string): string | undefined {
+	if (!name) {
+		return "Host name cannot be empty";
+	}
+	if (name.length > 100) {
+		return "Host name is too long (max 100 characters)";
+	}
+	// Check for invalid characters (only allow alphanumeric, dash, underscore, dot)
+	if (!/^[a-zA-Z0-9_.-]+$/.test(name)) {
+		return "Host name can only contain letters, numbers, dash, underscore, and dot";
+	}
+	return undefined;
+}
+
+/**
+ * Add an SSH host to a config file.
+ *
+ * @throws Error if host name already exists or validation fails
+ */
+export async function addSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void> {
+	// Validate host name
+	const nameError = validateHostName(name);
+	if (nameError) {
+		throw new Error(nameError);
+	}
+
+	// Validate host field
+	if (!hostConfig.host) {
+		throw new Error("Host address cannot be empty");
+	}
+
+	// Read existing config
+	const existing = await readSSHConfigFile(filePath);
+
+	// Check for duplicate name
+	if (existing.hosts?.[name]) {
+		throw new Error(`Host "${name}" already exists in ${filePath}`);
+	}
+
+	// Add host
+	const updated: SSHConfigFile = {
+		...existing,
+		hosts: {
+			...existing.hosts,
+			[name]: hostConfig,
+		},
+	};
+
+	// Write back
+	await writeSSHConfigFile(filePath, updated);
+}
+
+/**
+ * Update an existing SSH host in a config file.
+ * If the host doesn't exist, this will add it.
+ *
+ * @throws Error if validation fails
+ */
+export async function updateSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void> {
+	// Validate host name
+	const nameError = validateHostName(name);
+	if (nameError) {
+		throw new Error(nameError);
+	}
+
+	// Validate host field
+	if (!hostConfig.host) {
+		throw new Error("Host address cannot be empty");
+	}
+
+	// Read existing config
+	const existing = await readSSHConfigFile(filePath);
+
+	// Update host
+	const updated: SSHConfigFile = {
+		...existing,
+		hosts: {
+			...existing.hosts,
+			[name]: hostConfig,
+		},
+	};
+
+	// Write back
+	await writeSSHConfigFile(filePath, updated);
+}
+
+/**
+ * Remove an SSH host from a config file.
+ *
+ * @throws Error if host doesn't exist
+ */
+export async function removeSSHHost(filePath: string, name: string): Promise<void> {
+	// Read existing config
+	const existing = await readSSHConfigFile(filePath);
+
+	// Check if host exists
+	if (!existing.hosts?.[name]) {
+		throw new Error(`Host "${name}" not found in ${filePath}`);
+	}
+
+	// Remove host
+	const { [name]: _removed, ...remaining } = existing.hosts;
+	const updated: SSHConfigFile = {
+		...existing,
+		hosts: remaining,
+	};
+
+	// Write back
+	await writeSSHConfigFile(filePath, updated);
+}
+
+/**
+ * List all host names in a config file.
+ */
+export async function listSSHHosts(filePath: string): Promise<string[]> {
+	const config = await readSSHConfigFile(filePath);
+	return Object.keys(config.hosts ?? {});
+}