@f5xc-salesdemos/xcsh 19.9.1 → 19.10.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5xc-salesdemos/xcsh",
-	"version": "19.9.1",
+	"version": "19.10.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5xc-salesdemos/xcsh",
 	"author": "Can Boluk",
@@ -50,12 +50,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.16.1",
 		"@mozilla/readability": "^0.6",
-		"@f5xc-salesdemos/xcsh-stats": "19.9.1",
-		"@f5xc-salesdemos/pi-agent-core": "19.9.1",
-		"@f5xc-salesdemos/pi-ai": "19.9.1",
-		"@f5xc-salesdemos/pi-natives": "19.9.1",
-		"@f5xc-salesdemos/pi-tui": "19.9.1",
-		"@f5xc-salesdemos/pi-utils": "19.9.1",
+		"@f5xc-salesdemos/xcsh-stats": "19.10.0",
+		"@f5xc-salesdemos/pi-agent-core": "19.10.0",
+		"@f5xc-salesdemos/pi-ai": "19.10.0",
+		"@f5xc-salesdemos/pi-natives": "19.10.0",
+		"@f5xc-salesdemos/pi-tui": "19.10.0",
+		"@f5xc-salesdemos/pi-utils": "19.10.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.20",

package/src/extensibility/plugins/marketplace/prerequisites.ts

@@ -1,29 +1,230 @@
-import type { MarketplacePluginEntry } from "./types";
+import { logger } from "@f5xc-salesdemos/pi-utils";
 
-const cache = new Map<string, boolean>();
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface Prerequisite {
+	tool: string;
+	installCmd: string;
+	detectCmd: string;
+	authDetectCmd?: string;
+	authLoginCmd?: string;
+}
+
+export interface ToolStatus {
+	tool: string;
+	installed: boolean;
+	authenticated: boolean;
+	user?: string;
+	error?: string;
+}
+
+export interface SetupResult {
+	tool: string;
+	wasInstalled: boolean;
+	installAttempted: boolean;
+	installSuccess: boolean;
+	authenticated: boolean;
+	authLoginCmd?: string;
+	user?: string;
+	error?: string;
+}
+
+// ── Cache ────────────────────────────────────────────────────────────────────
+
+const detectCache = new Map<string, boolean>();
+
+export function clearPrerequisiteCache(): void {
+	detectCache.clear();
+}
+
+// ── Retry utility ────────────────────────────────────────────────────────────
+
+export async function withRetry<T>(
+	fn: () => Promise<T>,
+	opts: { maxRetries?: number; baseDelayMs?: number; label?: string } = {},
+): Promise<T> {
+	const maxRetries = opts.maxRetries ?? 3;
+	const baseDelayMs = opts.baseDelayMs ?? 1000;
+	let lastError: unknown;
+
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		try {
+			return await fn();
+		} catch (err) {
+			lastError = err;
+			if (attempt < maxRetries) {
+				const delay = baseDelayMs * 2 ** attempt;
+				logger.debug(`Retry ${attempt + 1}/${maxRetries} for ${opts.label ?? "operation"} in ${delay}ms`);
+				await new Promise(resolve => setTimeout(resolve, delay));
+			}
+		}
+	}
+
+	throw lastError;
+}
+
+// ── Tool detection ───────────────────────────────────────────────────────────
 
 export async function checkPrerequisite(detectCmd: string): Promise<boolean> {
-	const cached = cache.get(detectCmd);
+	const cached = detectCache.get(detectCmd);
 	if (cached !== undefined) return cached;
 
 	try {
 		const [cmd, ...args] = detectCmd.split(/\s+/);
-		const proc = Bun.spawn([cmd!, ...args], {
-			stdout: "ignore",
-			stderr: "ignore",
-		});
+		const proc = Bun.spawn([cmd!, ...args], { stdout: "ignore", stderr: "ignore" });
 		const exitCode = await proc.exited;
 		const available = exitCode === 0;
-		cache.set(detectCmd, available);
+		detectCache.set(detectCmd, available);
 		return available;
 	} catch {
-		cache.set(detectCmd, false);
+		detectCache.set(detectCmd, false);
 		return false;
 	}
 }
 
+// ── Tool installation ────────────────────────────────────────────────────────
+
+export async function installTool(
+	installCmd: string,
+	opts?: { maxRetries?: number; baseDelayMs?: number },
+): Promise<{ success: boolean; error?: string }> {
+	try {
+		await withRetry(
+			async () => {
+				const parts = installCmd.split(/\s+/);
+				const proc = Bun.spawn(parts, { stdout: "ignore", stderr: "pipe" });
+				const exitCode = await proc.exited;
+				if (exitCode !== 0) {
+					const stderr = await new Response(proc.stderr).text();
+					throw new Error(stderr.trim() || `exit code ${exitCode}`);
+				}
+			},
+			{ maxRetries: opts?.maxRetries ?? 2, baseDelayMs: opts?.baseDelayMs ?? 2000, label: installCmd },
+		);
+		return { success: true };
+	} catch (err) {
+		return { success: false, error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
+// ── Auth detection ───────────────────────────────────────────────────────────
+
+export async function checkAuth(
+	authDetectCmd: string,
+): Promise<{ authenticated: boolean; user?: string; error?: string }> {
+	try {
+		const parts = authDetectCmd.split(/\s+/);
+		const proc = Bun.spawn(parts, { stdout: "pipe", stderr: "pipe" });
+		const exitCode = await proc.exited;
+
+		if (exitCode !== 0) {
+			return { authenticated: false };
+		}
+
+		let user: string | undefined;
+		try {
+			const stdout = await new Response(proc.stdout).text();
+			const parsed = JSON.parse(stdout);
+			user = parsed?.user?.name ?? parsed?.Account ?? parsed?.login ?? parsed?.username;
+		} catch {
+			// Non-JSON output is fine — exit code 0 means authenticated
+		}
+
+		return { authenticated: true, user };
+	} catch {
+		return { authenticated: false, error: "auth check command failed" };
+	}
+}
+
+// ── Full tool readiness check ────────────────────────────────────────────────
+
+export async function checkToolReady(prereq: Prerequisite): Promise<ToolStatus> {
+	const installed = await checkPrerequisite(prereq.detectCmd);
+	if (!installed) {
+		return { tool: prereq.tool, installed: false, authenticated: false };
+	}
+
+	if (!prereq.authDetectCmd) {
+		return { tool: prereq.tool, installed: true, authenticated: true };
+	}
+
+	const auth = await checkAuth(prereq.authDetectCmd);
+	return {
+		tool: prereq.tool,
+		installed: true,
+		authenticated: auth.authenticated,
+		user: auth.user,
+	};
+}
+
+// ── Full setup orchestration for one tool ────────────────────────────────────
+
+export async function setupTool(prereq: Prerequisite): Promise<SetupResult> {
+	// Step 1: Check if already installed
+	let installed = await checkPrerequisite(prereq.detectCmd);
+	let installAttempted = false;
+	let installSuccess = false;
+
+	if (!installed) {
+		// Step 2: Attempt installation with retry
+		installAttempted = true;
+		detectCache.delete(prereq.detectCmd);
+		const result = await installTool(prereq.installCmd);
+		installSuccess = result.success;
+
+		if (!result.success) {
+			return {
+				tool: prereq.tool,
+				wasInstalled: false,
+				installAttempted: true,
+				installSuccess: false,
+				authenticated: false,
+				error: `Install failed: ${result.error}`,
+			};
+		}
+
+		// Verify installation
+		detectCache.delete(prereq.detectCmd);
+		installed = await checkPrerequisite(prereq.detectCmd);
+		if (!installed) {
+			return {
+				tool: prereq.tool,
+				wasInstalled: false,
+				installAttempted: true,
+				installSuccess: false,
+				authenticated: false,
+				error: "Install appeared to succeed but tool not found on PATH",
+			};
+		}
+	}
+
+	// Step 3: Check auth
+	if (!prereq.authDetectCmd) {
+		return {
+			tool: prereq.tool,
+			wasInstalled: !installAttempted,
+			installAttempted,
+			installSuccess: installAttempted ? true : false,
+			authenticated: true,
+		};
+	}
+
+	const auth = await checkAuth(prereq.authDetectCmd);
+	return {
+		tool: prereq.tool,
+		wasInstalled: !installAttempted,
+		installAttempted,
+		installSuccess: installAttempted ? true : false,
+		authenticated: auth.authenticated,
+		user: auth.user,
+		authLoginCmd: auth.authenticated ? undefined : prereq.authLoginCmd,
+	};
+}
+
+// ── Batch operations ─────────────────────────────────────────────────────────
+
 export async function checkAllPrerequisites(
-	plugins: MarketplacePluginEntry[],
+	plugins: Array<{ name: string; prerequisites?: Prerequisite[] }>,
 ): Promise<Map<string, { available: boolean; missing: string[] }>> {
 	const results = new Map<string, { available: boolean; missing: string[] }>();
 
@@ -45,6 +246,10 @@ export async function checkAllPrerequisites(
 	return results;
 }
 
-export function clearPrerequisiteCache(): void {
-	cache.clear();
+export async function setupAllTools(prerequisites: Prerequisite[]): Promise<SetupResult[]> {
+	const results: SetupResult[] = [];
+	for (const prereq of prerequisites) {
+		results.push(await setupTool(prereq));
+	}
+	return results;
 }

package/src/extensibility/plugins/marketplace/types.ts

@@ -90,7 +90,13 @@ export interface MarketplacePluginEntry {
 	strict?: boolean;
 	defaultEnabled?: boolean;
 	recommended?: boolean;
-	prerequisites?: Array<{ tool: string; installCmd: string; detectCmd: string }>;
+	prerequisites?: Array<{
+		tool: string;
+		installCmd: string;
+		detectCmd: string;
+		authDetectCmd?: string;
+		authLoginCmd?: string;
+	}>;
 	commands?: string | string[];
 	agents?: string | string[];
 	hooks?: string | Record<string, unknown>;

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

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "19.9.1",
-	"commit": "d3150a05f1d9eb0b91c234b970ed08b8f679ad3f",
-	"shortCommit": "d3150a0",
+	"version": "19.10.0",
+	"commit": "d46f8e9c1e3828c21cfa36c04509b3ec562d3d07",
+	"shortCommit": "d46f8e9",
 	"branch": "main",
-	"tag": "v19.9.1",
-	"commitDate": "2026-06-05T02:56:19Z",
-	"buildDate": "2026-06-05T03:25:42.133Z",
+	"tag": "v19.10.0",
+	"commitDate": "2026-06-05T04:49:35Z",
+	"buildDate": "2026-06-05T05:11:51.351Z",
 	"dirty": true,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5xc-salesdemos/xcsh",
 	"repoSlug": "f5xc-salesdemos/xcsh",
-	"commitUrl": "https://github.com/f5xc-salesdemos/xcsh/commit/d3150a05f1d9eb0b91c234b970ed08b8f679ad3f",
-	"releaseUrl": "https://github.com/f5xc-salesdemos/xcsh/releases/tag/v19.9.1"
+	"commitUrl": "https://github.com/f5xc-salesdemos/xcsh/commit/d46f8e9c1e3828c21cfa36c04509b3ec562d3d07",
+	"releaseUrl": "https://github.com/f5xc-salesdemos/xcsh/releases/tag/v19.10.0"
 };

package/src/modes/components/plugins/plugin-dashboard.ts

@@ -290,6 +290,7 @@ export class PluginDashboard extends Container {
 	}
 
 	async #installAllRecommended(): Promise<void> {
+		const { setupTool } = await import("../../../extensibility/plugins/marketplace/prerequisites");
 		const recommended = this.#state.allPlugins.filter(p => !p.installed && p.recommended && p.marketplace);
 		if (recommended.length === 0) {
 			this.#state.notice = "All recommended plugins are already installed";
@@ -297,12 +298,33 @@ export class PluginDashboard extends Container {
 			return;
 		}
 
-		this.#state.notice = `Installing ${recommended.length} recommended plugin(s)...`;
-		this.#rebuildAndRender();
-
 		let installed = 0;
 		let failed = 0;
+		const authNeeded: string[] = [];
+
 		for (const plugin of recommended) {
+			this.#state.notice = `Setting up ${plugin.displayName || plugin.name}... (${installed + failed + 1}/${recommended.length})`;
+			this.#rebuildAndRender();
+
+			// Check and install prerequisites
+			if (plugin.prerequisites && plugin.prerequisites.length > 0) {
+				let prereqReady = true;
+				for (const prereq of plugin.prerequisites) {
+					const result = await setupTool(prereq);
+					if (!result.installSuccess && result.installAttempted) {
+						prereqReady = false;
+						break;
+					}
+					if (!result.authenticated && prereq.authLoginCmd) {
+						authNeeded.push(`${prereq.tool}: ${prereq.authLoginCmd}`);
+					}
+				}
+				if (!prereqReady) {
+					failed++;
+					continue;
+				}
+			}
+
 			try {
 				await this.#mgr.installPlugin(plugin.name, plugin.marketplace!);
 				installed++;
@@ -311,10 +333,10 @@ export class PluginDashboard extends Container {
 			}
 		}
 
-		this.#state.notice =
-			failed > 0
-				? `Installed ${installed}/${recommended.length} recommended plugin(s), ${failed} failed`
-				: `Installed ${installed} recommended plugin(s)`;
+		const parts = [`Installed ${installed}/${recommended.length} recommended plugin(s)`];
+		if (failed > 0) parts.push(`${failed} failed`);
+		if (authNeeded.length > 0) parts.push(`Auth needed: ${authNeeded.join(", ")}`);
+		this.#state.notice = parts.join(". ");
 		await this.#reloadData();
 	}
 

package/src/modes/components/plugins/types.ts

@@ -19,7 +19,13 @@ export interface DashboardPlugin {
 	hasUpdate: boolean;
 	updateVersion?: string;
 	recommended?: boolean;
-	prerequisites?: Array<{ tool: string; installCmd: string; detectCmd: string }>;
+	prerequisites?: Array<{
+		tool: string;
+		installCmd: string;
+		detectCmd: string;
+		authDetectCmd?: string;
+		authLoginCmd?: string;
+	}>;
 }
 
 export type PluginTabId = "installed" | "recommended" | "discover" | "updates";

package/src/slash-commands/builtin-registry.ts

@@ -1164,7 +1164,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 					}
 					// ── Setup (guided recommended plugin install) ──
 					case "setup": {
-						const { checkPrerequisite } = await import("../extensibility/plugins/marketplace/prerequisites");
+						const { setupTool } = await import("../extensibility/plugins/marketplace/prerequisites");
 						const allPlugins = await mgr.listAvailablePlugins();
 						const recommended = allPlugins.filter(p => p.recommended);
 						if (recommended.length === 0) {
@@ -1172,66 +1172,86 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 							break;
 						}
 
-						const installed = await mgr.listInstalledPlugins();
-						const installedIds = new Set(installed.map(p => p.id));
-						const toInstall = recommended.filter(
+						const installedPlugins = await mgr.listInstalledPlugins();
+						const installedIds = new Set(installedPlugins.map(p => p.id));
+						const toSetup = recommended.filter(
 							p => !Array.from(installedIds).some(id => id.startsWith(`${p.name}@`)),
 						);
 
-						if (toInstall.length === 0) {
+						if (toSetup.length === 0) {
 							runtime.ctx.showStatus("All recommended plugins are already installed");
 							break;
 						}
 
 						const lines: string[] = ["Recommended plugins setup:\n"];
-						let installedCount = 0;
+						let pluginInstalledCount = 0;
 						let skippedCount = 0;
-						const skippedReasons: string[] = [];
 
-						for (const plugin of toInstall) {
+						for (const plugin of toSetup) {
+							const name = plugin.displayName || plugin.name;
+
+							// Step 1: Setup prerequisites (detect → install → auth)
 							if (plugin.prerequisites && plugin.prerequisites.length > 0) {
-								const missing: string[] = [];
+								let allReady = true;
 								for (const prereq of plugin.prerequisites) {
-									const ok = await checkPrerequisite(prereq.detectCmd);
-									if (!ok) missing.push(`${prereq.tool} (${prereq.installCmd})`);
+									const result = await setupTool(prereq);
+
+									if (!result.installSuccess && result.installAttempted) {
+										lines.push(`  x ${name} — ${prereq.tool}: install failed (${result.error})`);
+										lines.push(`    Fix: ${prereq.installCmd}`);
+										allReady = false;
+										break;
+									}
+
+									if (result.installAttempted && result.installSuccess) {
+										lines.push(`  + ${name} — ${prereq.tool}: installed`);
+									}
+
+									if (!result.authenticated && prereq.authLoginCmd) {
+										lines.push(`  ~ ${name} — ${prereq.tool}: not authenticated`);
+										lines.push(`    Run: ${prereq.authLoginCmd}`);
+									} else if (result.authenticated && result.user) {
+										lines.push(`  ✓ ${name} — ${prereq.tool}: authenticated as ${result.user}`);
+									} else if (result.authenticated) {
+										lines.push(`  ✓ ${name} — ${prereq.tool}: ready`);
+									}
 								}
-								if (missing.length > 0) {
-									lines.push(`  ⊘ ${plugin.displayName || plugin.name} — missing: ${missing.join(", ")}`);
+								if (!allReady) {
 									skippedCount++;
-									skippedReasons.push(...missing);
 									continue;
 								}
 							}
 
+							// Step 2: Install the plugin
 							const marketplaces = await mgr.listMarketplaces();
-							let installed = false;
+							let didInstall = false;
 							for (const mkt of marketplaces) {
 								const available = await mgr.listAvailablePlugins(mkt.name);
 								if (available.some(a => a.name === plugin.name)) {
 									try {
 										await mgr.installPlugin(plugin.name, mkt.name);
-										lines.push(`  + ${plugin.displayName || plugin.name} — installed`);
-										installedCount++;
-										installed = true;
+										lines.push(`  ✓ ${name} — plugin installed`);
+										pluginInstalledCount++;
+										didInstall = true;
 									} catch (err) {
 										lines.push(
-											`  ! ${plugin.displayName || plugin.name} — ${err instanceof Error ? err.message : String(err)}`,
+											`  ! ${name} — plugin install failed: ${err instanceof Error ? err.message : String(err)}`,
 										);
 										skippedCount++;
 									}
 									break;
 								}
 							}
-							if (!installed && skippedCount === 0) {
-								lines.push(`  ? ${plugin.displayName || plugin.name} — not found in any marketplace`);
+							if (!didInstall && skippedCount === 0) {
+								lines.push(`  ? ${name} — not found in any marketplace`);
 								skippedCount++;
 							}
 						}
 
 						lines.push("");
-						lines.push(`Installed ${installedCount}/${toInstall.length} recommended plugin(s)`);
+						lines.push(`Installed ${pluginInstalledCount}/${toSetup.length} recommended plugin(s)`);
 						if (skippedCount > 0) {
-							lines.push(`${skippedCount} skipped — install missing tools and run /plugin setup again`);
+							lines.push(`${skippedCount} skipped — fix issues above and run /plugin setup again (idempotent)`);
 						}
 						runtime.ctx.showStatus(lines.join("\n"));
 						break;