@f5xc-salesdemos/xcsh 19.9.1 → 19.11.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5xc-salesdemos/xcsh",
-	"version": "19.9.1",
+	"version": "19.11.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.11.0",
+		"@f5xc-salesdemos/pi-agent-core": "19.11.0",
+		"@f5xc-salesdemos/pi-ai": "19.11.0",
+		"@f5xc-salesdemos/pi-natives": "19.11.0",
+		"@f5xc-salesdemos/pi-tui": "19.11.0",
+		"@f5xc-salesdemos/pi-utils": "19.11.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.11.0",
+	"commit": "f1aa8804fd9d391462a8c13d4ff0de70b01e20b8",
+	"shortCommit": "f1aa880",
 	"branch": "main",
-	"tag": "v19.9.1",
-	"commitDate": "2026-06-05T02:56:19Z",
-	"buildDate": "2026-06-05T03:25:42.133Z",
+	"tag": "v19.11.0",
+	"commitDate": "2026-06-05T12:59:46Z",
+	"buildDate": "2026-06-05T13:30:16.635Z",
 	"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/f1aa8804fd9d391462a8c13d4ff0de70b01e20b8",
+	"releaseUrl": "https://github.com/f5xc-salesdemos/xcsh/releases/tag/v19.11.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/state-manager.ts

@@ -3,12 +3,9 @@ import type { MarketplaceManager } from "../../../extensibility/plugins/marketpl
 import type { InstalledPluginSummary, MarketplacePluginEntry } from "../../../extensibility/plugins/marketplace/types";
 import type { DashboardPlugin, PluginDashboardState, PluginTab, PluginTabId } from "./types";
 
-export function normalizePluginDisplayName(name: string): string {
-	let result = name;
-	if (result.startsWith("f5xc-")) result = result.slice(5);
-	if (result.length > 0 && result.endsWith("-status")) result = result.slice(0, -7);
-	return result || name;
-}
+export { normalizePluginDisplayName } from "./utils";
+
+import { normalizePluginDisplayName } from "./utils";
 
 function npmToDashboard(npm: { name: string; version: string; enabled: boolean }): DashboardPlugin {
 	return {

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/modes/components/plugins/utils.ts

@@ -0,0 +1,6 @@
+export function normalizePluginDisplayName(name: string): string {
+	let result = name;
+	if (result.startsWith("f5xc-")) result = result.slice(5);
+	if (result.length > 0 && result.endsWith("-status")) result = result.slice(0, -7);
+	return result || name;
+}

package/src/modes/components/welcome-checks.ts

@@ -1,9 +1,17 @@
 import type { Model } from "@f5xc-salesdemos/pi-ai";
 import { validateApiKeyAgainstModelsEndpoint } from "@f5xc-salesdemos/pi-ai/utils/oauth/api-key-validation";
 import { logger } from "@f5xc-salesdemos/pi-utils";
+import { MarketplaceManager } from "../../extensibility/plugins/marketplace";
+import {
+	getInstalledPluginsRegistryPath,
+	getMarketplacesCacheDir,
+	getMarketplacesRegistryPath,
+	getPluginsCacheDir,
+} from "../../extensibility/plugins/marketplace/registry";
 import { type AuthStatus, ContextService } from "../../services/f5xc-context";
 import { deriveTenantFromUrl } from "../../services/f5xc-env";
 import type { AuthStorage } from "../../session/auth-storage";
+import { normalizePluginDisplayName } from "./plugins/utils";
 
 // Startup validation budget. These are longer than validateToken's 3000ms default because
 // the welcome path runs during TLS/DNS cold-start — a single 3s shot races against warm-up
@@ -214,3 +222,45 @@ export interface FixableService {
 	command: string[];
 	recheck: () => Promise<ServiceStatus>;
 }
+
+export interface RecommendedPluginStatus {
+	name: string;
+	installed: boolean;
+}
+
+export async function checkRecommendedPlugins(): Promise<RecommendedPluginStatus[]> {
+	try {
+		const mgr = new MarketplaceManager({
+			marketplacesRegistryPath: getMarketplacesRegistryPath(),
+			installedRegistryPath: getInstalledPluginsRegistryPath(),
+			marketplacesCacheDir: getMarketplacesCacheDir(),
+			pluginsCacheDir: getPluginsCacheDir(),
+			clearPluginRootsCache: () => {},
+		});
+
+		const [marketplaces, installedSummaries] = await Promise.all([
+			mgr.listMarketplaces(),
+			mgr.listInstalledPlugins(),
+		]);
+
+		const installedIds = new Set(installedSummaries.map(s => s.id));
+		const results: RecommendedPluginStatus[] = [];
+
+		for (const mkt of marketplaces) {
+			const available = await mgr.listAvailablePlugins(mkt.name).catch(() => []);
+			for (const entry of available) {
+				if (!entry.recommended) continue;
+				const pluginId = `${entry.name}@${mkt.name}`;
+				results.push({
+					name: normalizePluginDisplayName(entry.name),
+					installed: installedIds.has(pluginId),
+				});
+			}
+		}
+
+		return results.sort((a, b) => a.name.localeCompare(b.name));
+	} catch (err) {
+		logger.debug("checkRecommendedPlugins failed", { error: String(err) });
+		return [];
+	}
+}

package/src/modes/components/welcome.ts

@@ -2,7 +2,7 @@ import { type Component, padding, truncateToWidth, visibleWidth } from "@f5xc-sa
 import { APP_NAME } from "@f5xc-salesdemos/pi-utils";
 import { theme } from "../../modes/theme/theme";
 import { formatStatusIcon } from "../../services/f5xc-context-indicators";
-import type { ModelStatus, ServiceStatus } from "./welcome-checks";
+import type { ModelStatus, RecommendedPluginStatus, ServiceStatus } from "./welcome-checks";
 
 export interface UpdateStatus {
 	available: boolean;
@@ -15,6 +15,7 @@ export class WelcomeComponent implements Component {
 		private modelStatus: ModelStatus,
 		private services: ServiceStatus[] = [],
 		private updateStatus?: UpdateStatus,
+		private recommendedPlugins: RecommendedPluginStatus[] = [],
 	) {}
 	invalidate(): void {}
 	setModelStatus(status: ModelStatus): void {
@@ -26,6 +27,9 @@ export class WelcomeComponent implements Component {
 	setUpdateStatus(status: UpdateStatus | undefined): void {
 		this.updateStatus = status;
 	}
+	setRecommendedPlugins(plugins: RecommendedPluginStatus[]): void {
+		this.recommendedPlugins = plugins;
+	}
 
 	render(termWidth: number): string[] {
 		const minLeftCol = 48;
@@ -136,6 +140,12 @@ export class WelcomeComponent implements Component {
 				lines.push(this.#renderServiceLine(svc));
 			}
 		}
+		if (this.recommendedPlugins.length > 0) {
+			lines.push(" Recommended Plugins");
+			for (const p of this.recommendedPlugins) {
+				lines.push(this.#renderRecommendedLine(p));
+			}
+		}
 		if (this.#showUpdateSection()) {
 			lines.push(this.#renderUpdateLine());
 		}
@@ -163,7 +173,11 @@ export class WelcomeComponent implements Component {
 		lines.push("");
 		const coreServices = this.services.filter(s => !s._isPlugin);
 		const pluginServices = this.services.filter(s => s._isPlugin);
-		const hasContent = coreServices.length > 0 || pluginServices.length > 0 || this.#showUpdateSection();
+		const hasContent =
+			coreServices.length > 0 ||
+			pluginServices.length > 0 ||
+			this.recommendedPlugins.length > 0 ||
+			this.#showUpdateSection();
 		if (hasContent) {
 			lines.push(separator);
 			for (const svc of coreServices) {
@@ -179,6 +193,18 @@ export class WelcomeComponent implements Component {
 					}
 				}
 			}
+			if (this.recommendedPlugins.length > 0) {
+				lines.push("");
+				lines.push(` ${theme.fg("dim", "Recommended Plugins")}`);
+				for (const p of this.recommendedPlugins) {
+					lines.push(this.#renderRecommendedLine(p));
+				}
+				const missing = this.recommendedPlugins.filter(p => !p.installed);
+				if (missing.length > 0) {
+					lines.push(`   ${theme.fg("dim", "run: /plugin setup")}`);
+				}
+			}
+
 			if (this.#showUpdateSection()) {
 				lines.push(this.#renderUpdateLine());
 			}
@@ -187,6 +213,13 @@ export class WelcomeComponent implements Component {
 		return lines;
 	}
 
+	#renderRecommendedLine(plugin: RecommendedPluginStatus): string {
+		if (plugin.installed) {
+			return ` ${formatStatusIcon("connected")} ${theme.fg("muted", plugin.name)}`;
+		}
+		return ` ${theme.fg("dim", "·")} ${theme.fg("dim", plugin.name)}`;
+	}
+
 	#showUpdateSection(): boolean {
 		return this.updateStatus?.available === true;
 	}

package/src/modes/interactive-mode.ts

@@ -53,6 +53,7 @@ import { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import { type UpdateStatus, WelcomeComponent } from "./components/welcome";
 import {
+	checkRecommendedPlugins,
 	type FixableService,
 	mapContextStatus,
 	runWelcomeChecks,
@@ -386,12 +387,15 @@ export class InteractiveMode implements InteractiveModeContext {
 			}
 		}
 
+		const recommendedPlugins = !startupQuiet ? await checkRecommendedPlugins().catch(() => []) : [];
+
 		if (!startupQuiet) {
 			this.#welcomeComponent = new WelcomeComponent(
 				this.#version,
 				welcomeResult.model,
 				services,
 				this.#initialUpdateStatus,
+				recommendedPlugins,
 			);
 
 			// Setup UI layout

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;