@agentuity/cli 2.0.12 → 2.0.14

package/src/cmd/cloud/sandbox/snapshot/create.ts

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { getCommand } from '../../../../command-prefix';
 import * as tui from '../../../../tui';
 import { createCommand } from '../../../../types';
-import { createSandboxClient, getSandboxRegion } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 
 const SNAPSHOT_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
 const SNAPSHOT_TAG_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
@@ -88,15 +88,15 @@ export const createSubcommand = createCommand({
 		}
 
 		const profileName = config?.name;
-		const region = await getSandboxRegion(
+		const sandboxInfo = await resolveSandboxTarget(
 			logger,
 			auth,
-			profileName,
+			null,
 			args.sandboxId,
-			orgId,
+			profileName,
 			config
 		);
-		const client = createSandboxClient(logger, auth, region);
+		const client = createSandboxClient(logger, auth, sandboxInfo.region);
 
 		const snapshot = await snapshotCreate(client, {
 			sandboxId: args.sandboxId,
@@ -104,7 +104,7 @@ export const createSubcommand = createCommand({
 			description: opts.description,
 			tag: opts.tag,
 			public: opts.public,
-			orgId,
+			orgId: sandboxInfo.orgId ?? orgId,
 		});
 
 		if (!options.json) {

package/src/cmd/coder/start.ts

@@ -391,6 +391,7 @@ export const startSubcommand = createSubcommand({
 		};
 		env.AGENTUITY_CODER_API_KEY = ctx.auth.apiKey;
 		env.AGENTUITY_ORGID = ctx.orgId;
+		env.PI_SKIP_VERSION_CHECK = '1';
 
 		if (opts?.agent) {
 			env.AGENTUITY_CODER_AGENT = opts.agent;

package/src/cmd/coder/workspace/common.ts

@@ -0,0 +1,103 @@
+import {
+	type CoderCreateWorkspaceRequest,
+	type CoderUpdateWorkspaceRequest,
+	type CoderWorkspaceDetail,
+} from '@agentuity/core/coder';
+import { StructuredError } from '@agentuity/core';
+import * as tui from '../../../tui';
+
+export const EMPTY_WORKSPACE_ERROR =
+	'A workspace needs at least one repo, dependency, setup script, saved skill, skill bucket, or agent';
+export const SetupScriptValidationError = StructuredError('SetupScriptValidationError')<{
+	message: string;
+	path?: string;
+}>();
+
+export function parseCommaList(value?: string): string[] {
+	return value
+		? value
+				.split(',')
+				.map((item) => item.trim())
+				.filter(Boolean)
+		: [];
+}
+
+export async function readSetupScript(input: {
+	setupScript?: string;
+	setupScriptFile?: string;
+}): Promise<string | undefined> {
+	if (input.setupScript !== undefined && input.setupScriptFile) {
+		throw new SetupScriptValidationError({
+			message: 'Use either --setup-script or --setup-script-file, not both.',
+		});
+	}
+	if (input.setupScript !== undefined) return input.setupScript;
+	if (!input.setupScriptFile) return undefined;
+	try {
+		return await Bun.file(input.setupScriptFile).text();
+	} catch (error) {
+		throw new SetupScriptValidationError({
+			message: `Failed to read setup script file "${input.setupScriptFile}": ${
+				error instanceof Error ? error.message : String(error)
+			}`,
+			path: input.setupScriptFile,
+			cause: error,
+		});
+	}
+}
+
+export function hasWorkspaceSelections(input: CoderCreateWorkspaceRequest): boolean {
+	return (
+		(input.repos?.length ?? 0) > 0 ||
+		(input.dependencies?.length ?? 0) > 0 ||
+		Boolean(input.setupScript?.trim()) ||
+		(input.savedSkillIds?.length ?? 0) > 0 ||
+		(input.skillBucketIds?.length ?? 0) > 0 ||
+		(input.enabledAgents?.length ?? 0) > 0
+	);
+}
+
+export function hasWorkspaceUpdate(input: CoderUpdateWorkspaceRequest): boolean {
+	return Object.keys(input).length > 0;
+}
+
+export function formatWorkspaceValidationMessage(issues: Array<{ message: string }>): string {
+	const messages = [...new Set(issues.map((issue) => issue.message).filter(Boolean))];
+	if (messages.length === 0) {
+		return 'Invalid workspace configuration';
+	}
+	if (messages.includes(EMPTY_WORKSPACE_ERROR)) {
+		return `${EMPTY_WORKSPACE_ERROR}. Use --repo, --dependency, --setup-script, or --enabled-agents.`;
+	}
+	return messages.join('; ');
+}
+
+export function printWorkspaceSummary(workspace: CoderWorkspaceDetail): void {
+	const enabledAgents = Array.isArray(workspace.enabledAgents)
+		? workspace.enabledAgents.filter((name): name is string => typeof name === 'string')
+		: [];
+	const dependencies = Array.isArray(workspace.dependencies) ? workspace.dependencies : [];
+
+	tui.output(`  Name:        ${tui.bold(workspace.name)}`);
+	if (workspace.description) {
+		tui.output(`  Description: ${workspace.description}`);
+	}
+	tui.output(`  Scope:       ${workspace.scope}`);
+	tui.output(`  Repos:       ${workspace.repoCount}`);
+	tui.output(`  Selections:  ${workspace.selectionCount}`);
+	if (dependencies.length > 0) {
+		tui.output(`  Dependencies:${dependencies.length === 1 ? ` ${dependencies[0]}` : ''}`);
+		for (const dependency of dependencies.length === 1 ? [] : dependencies) {
+			tui.output(`    - ${dependency}`);
+		}
+	}
+	if (workspace.setupScript) {
+		tui.output('  Setup:       configured');
+	}
+	if (workspace.snapshot?.status) {
+		tui.output(`  Snapshot:    ${workspace.snapshot.status}`);
+	}
+	if (enabledAgents.length > 0) {
+		tui.output(`  Agents:      ${enabledAgents.join(', ')}`);
+	}
+}

package/src/cmd/coder/workspace/create.ts

@@ -10,29 +10,14 @@ import * as tui from '../../../tui';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 import { resolveGitHubRepo } from '../resolve-repo';
-
-const EMPTY_WORKSPACE_ERROR =
-	'A workspace needs at least one repo, saved skill, skill bucket, or agent';
-
-function hasWorkspaceSelections(input: CoderCreateWorkspaceRequest): boolean {
-	return (
-		(input.repos?.length ?? 0) > 0 ||
-		(input.savedSkillIds?.length ?? 0) > 0 ||
-		(input.skillBucketIds?.length ?? 0) > 0 ||
-		(input.enabledAgents?.length ?? 0) > 0
-	);
-}
-
-function formatWorkspaceValidationMessage(issues: Array<{ message: string }>): string {
-	const messages = [...new Set(issues.map((issue) => issue.message).filter(Boolean))];
-	if (messages.length === 0) {
-		return 'Invalid workspace configuration';
-	}
-	if (messages.includes(EMPTY_WORKSPACE_ERROR)) {
-		return `${EMPTY_WORKSPACE_ERROR}. Use --repo or --enabled-agents.`;
-	}
-	return messages.join('; ');
-}
+import {
+	EMPTY_WORKSPACE_ERROR,
+	formatWorkspaceValidationMessage,
+	hasWorkspaceSelections,
+	parseCommaList,
+	printWorkspaceSummary,
+	readSetupScript,
+} from './common';
 
 export const createWorkspaceSubcommand = createSubcommand({
 	name: 'create',
@@ -49,9 +34,9 @@ export const createWorkspaceSubcommand = createSubcommand({
 		},
 		{
 			command: getCommand(
-				'coder workspace create "My Workspace" --enabled-agents code-review --description "For frontend work" --scope org'
+				'coder workspace create "My Workspace" --dependency git --setup-script-file ./setup.sh --scope org'
 			),
-			description: 'Create an org-scoped workspace with description and agents',
+			description: 'Create an org-scoped workspace with dependencies and a setup script',
 		},
 		{
 			command: getCommand('coder workspace create "My Workspace" --enabled-agents code-review'),
@@ -74,6 +59,18 @@ export const createWorkspaceSubcommand = createSubcommand({
 			scope: z.string().optional().describe('Workspace scope: user or org'),
 			repo: z.string().optional().describe('Repository URL to add'),
 			repoBranch: z.string().optional().describe('Branch for the repository'),
+			dependency: z
+				.string()
+				.optional()
+				.describe('Comma-separated APT dependencies to install into workspace snapshots'),
+			setupScript: z
+				.string()
+				.optional()
+				.describe('Inline shell script to run while preparing workspace snapshots'),
+			setupScriptFile: z
+				.string()
+				.optional()
+				.describe('Path to a shell script to run while preparing workspace snapshots'),
 			enabledAgents: z
 				.string()
 				.optional()
@@ -105,15 +102,26 @@ export const createWorkspaceSubcommand = createSubcommand({
 				return;
 			}
 		}
+		if (opts?.dependency) {
+			body.dependencies = parseCommaList(opts.dependency);
+		}
+		try {
+			const setupScript = await readSetupScript({
+				setupScript: opts?.setupScript,
+				setupScriptFile: opts?.setupScriptFile,
+			});
+			if (setupScript !== undefined) body.setupScript = setupScript;
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to read setup script: ${msg}`, ErrorCode.VALIDATION_FAILED);
+			return;
+		}
 		if (opts?.enabledAgents) {
-			body.enabledAgents = opts.enabledAgents
-				.split(',')
-				.map((name) => name.trim())
-				.filter(Boolean);
+			body.enabledAgents = parseCommaList(opts.enabledAgents);
 		}
 		if (!hasWorkspaceSelections(body)) {
 			tui.fatal(
-				`Failed to create workspace: ${EMPTY_WORKSPACE_ERROR}. Use --repo or --enabled-agents.`,
+				`Failed to create workspace: ${EMPTY_WORKSPACE_ERROR}. Use --repo, --dependency, --setup-script, or --enabled-agents.`,
 				ErrorCode.VALIDATION_FAILED
 			);
 		}
@@ -132,9 +140,6 @@ export const createWorkspaceSubcommand = createSubcommand({
 
 		try {
 			const created = await client.createWorkspace(validationResult.data);
-			const createdEnabledAgents = Array.isArray(created.enabledAgents)
-				? created.enabledAgents.filter((name): name is string => typeof name === 'string')
-				: [];
 
 			if (options.json) {
 				return created;
@@ -142,16 +147,7 @@ export const createWorkspaceSubcommand = createSubcommand({
 
 			tui.success(`Workspace ${created.id} created.`);
 			tui.newline();
-			tui.output(`  Name:        ${tui.bold(created.name)}`);
-			if (created.description) {
-				tui.output(`  Description: ${created.description}`);
-			}
-			tui.output(`  Scope:       ${created.scope}`);
-			tui.output(`  Repos:       ${created.repoCount}`);
-			tui.output(`  Selections:  ${created.selectionCount}`);
-			if (createdEnabledAgents.length > 0) {
-				tui.output(`  Agents:      ${createdEnabledAgents.join(', ')}`);
-			}
+			printWorkspaceSummary(created);
 
 			return created;
 		} catch (err) {

package/src/cmd/coder/workspace/get.ts

@@ -5,6 +5,7 @@ import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
+import { printWorkspaceSummary } from './common';
 
 function formatRelativeTime(isoDate: string): string {
 	const parsed = new Date(isoDate).getTime();
@@ -63,11 +64,7 @@ export const getWorkspaceSubcommand = createSubcommand({
 			tui.header(`Workspace: ${workspace.name}`);
 			tui.newline();
 			tui.output(`  ID:          ${workspace.id}`);
-			tui.output(`  Name:        ${tui.bold(workspace.name)}`);
-			if (workspace.description) {
-				tui.output(`  Description: ${workspace.description}`);
-			}
-			tui.output(`  Scope:       ${workspace.scope}`);
+			printWorkspaceSummary(workspace);
 			tui.output(`  Owner:       ${workspace.ownerUserId}`);
 			tui.output(`  Created:     ${formatRelativeTime(workspace.createdAt)}`);
 			tui.output(`  Updated:     ${formatRelativeTime(workspace.updatedAt)}`);

package/src/cmd/coder/workspace/index.ts

@@ -2,6 +2,9 @@ import { createCommand } from '../../../types';
 import { listSubcommand } from './list';
 import { createWorkspaceSubcommand } from './create';
 import { getWorkspaceSubcommand } from './get';
+import { refreshWorkspaceSnapshotSubcommand } from './refresh';
+import { updateWorkspaceSubcommand } from './update';
+import { validateWorkspaceDependenciesSubcommand } from './validate-dependencies';
 import { deleteWorkspaceSubcommand } from './delete';
 import { getCommand } from '../../../command-prefix';
 
@@ -30,11 +33,18 @@ export const workspaceCommand = createCommand({
 			command: getCommand('coder workspace delete ws_abc123'),
 			description: 'Delete a workspace',
 		},
+		{
+			command: getCommand('coder workspace validate-dependencies git,nodejs'),
+			description: 'Validate workspace dependencies',
+		},
 	],
 	subcommands: [
 		listSubcommand,
 		createWorkspaceSubcommand,
 		getWorkspaceSubcommand,
+		updateWorkspaceSubcommand,
+		refreshWorkspaceSnapshotSubcommand,
+		validateWorkspaceDependenciesSubcommand,
 		deleteWorkspaceSubcommand,
 	],
 });

package/src/cmd/coder/workspace/list.ts

@@ -83,6 +83,8 @@ export const listSubcommand = createSubcommand({
 				Name: w.name,
 				Scope: w.scope,
 				Repos: String(w.repoCount),
+				Deps: String(w.dependencies?.length ?? 0),
+				Snapshot: w.snapshot?.status ?? '',
 				Selections: String(w.selectionCount),
 				Created: formatRelativeTime(w.createdAt),
 			})),
@@ -91,6 +93,8 @@ export const listSubcommand = createSubcommand({
 				{ name: 'Name', alignment: 'left' },
 				{ name: 'Scope', alignment: 'center' },
 				{ name: 'Repos', alignment: 'right' },
+				{ name: 'Deps', alignment: 'right' },
+				{ name: 'Snapshot', alignment: 'left' },
 				{ name: 'Selections', alignment: 'right' },
 				{ name: 'Created', alignment: 'right' },
 			]

package/src/cmd/coder/workspace/refresh.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { APIError, ValidationOutputError } from '@agentuity/core';
+import { CoderClient } from '@agentuity/core/coder';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { printWorkspaceSummary } from './common';
+
+export const refreshWorkspaceSnapshotSubcommand = createSubcommand({
+	name: 'refresh',
+	aliases: ['snapshot-refresh', 'rebuild'],
+	description: 'Refresh a Coder workspace snapshot',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder workspace refresh ws_abc123'),
+			description: 'Queue a workspace snapshot refresh',
+		},
+	],
+	schema: {
+		args: z.object({
+			workspaceId: z.string().describe('Workspace ID to refresh'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		try {
+			const workspace = await client.refreshWorkspaceSnapshot(args.workspaceId);
+			if (options.json) {
+				return workspace;
+			}
+
+			tui.success(`Workspace ${workspace.id} snapshot refresh queued.`);
+			tui.newline();
+			printWorkspaceSummary(workspace);
+			return workspace;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			if (err instanceof APIError && err.status >= 400 && err.status < 500) {
+				tui.fatal(
+					`Failed to refresh workspace snapshot: ${err.message}`,
+					ErrorCode.VALIDATION_FAILED
+				);
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to refresh workspace snapshot: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});

package/src/cmd/coder/workspace/update.ts

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+import { APIError, ValidationInputError, ValidationOutputError } from '@agentuity/core';
+import {
+	CoderClient,
+	CoderUpdateWorkspaceRequestSchema,
+	type CoderUpdateWorkspaceRequest,
+} from '@agentuity/core/coder';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { resolveGitHubRepo } from '../resolve-repo';
+import {
+	formatWorkspaceValidationMessage,
+	hasWorkspaceUpdate,
+	parseCommaList,
+	printWorkspaceSummary,
+	readSetupScript,
+} from './common';
+
+export const updateWorkspaceSubcommand = createSubcommand({
+	name: 'update',
+	aliases: ['edit', 'patch'],
+	description: 'Update a Coder workspace',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder workspace update ws_abc123 --dependency git,nodejs'),
+			description: 'Update workspace dependencies',
+		},
+		{
+			command: getCommand('coder workspace update ws_abc123 --setup-script-file ./setup.sh'),
+			description: 'Update the workspace setup script',
+		},
+	],
+	schema: {
+		args: z.object({
+			workspaceId: z.string().describe('Workspace ID to update'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+			name: z.string().optional().describe('Workspace name'),
+			description: z.string().optional().describe('Workspace description'),
+			scope: z.string().optional().describe('Workspace scope: user or org'),
+			repo: z.string().optional().describe('Repository URL to set'),
+			repoBranch: z.string().optional().describe('Branch for the repository'),
+			dependency: z
+				.string()
+				.optional()
+				.describe('Comma-separated APT dependencies to install into workspace snapshots'),
+			setupScript: z
+				.string()
+				.optional()
+				.describe('Inline shell script to run while preparing workspace snapshots'),
+			setupScriptFile: z
+				.string()
+				.optional()
+				.describe('Path to a shell script to run while preparing workspace snapshots'),
+			enabledAgents: z
+				.string()
+				.optional()
+				.describe('Comma-separated built-in/custom agents to include'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		const body: CoderUpdateWorkspaceRequest = {
+			...(opts?.name && { name: opts.name }),
+			...(opts?.description && { description: opts.description }),
+			...(opts?.scope && { scope: opts.scope as 'user' | 'org' }),
+		};
+
+		if (opts?.repo) {
+			if (!options.json) tui.output('Resolving repository...');
+			try {
+				const resolved = await resolveGitHubRepo(client, opts.repo, opts?.repoBranch);
+				body.repos = [resolved];
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				tui.fatal(`Failed to resolve repository: ${msg}`, ErrorCode.VALIDATION_FAILED);
+				return;
+			}
+		}
+		if (opts?.dependency) {
+			body.dependencies = parseCommaList(opts.dependency);
+		}
+		try {
+			const setupScript = await readSetupScript({
+				setupScript: opts?.setupScript,
+				setupScriptFile: opts?.setupScriptFile,
+			});
+			if (setupScript !== undefined) body.setupScript = setupScript;
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to read setup script: ${msg}`, ErrorCode.VALIDATION_FAILED);
+			return;
+		}
+		if (opts?.enabledAgents) {
+			body.enabledAgents = parseCommaList(opts.enabledAgents);
+		}
+		if (!hasWorkspaceUpdate(body)) {
+			tui.fatal(
+				'Failed to update workspace: At least one field must be provided.',
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		const validationResult = CoderUpdateWorkspaceRequestSchema.safeParse(body);
+		if (!validationResult.success) {
+			ctx.logger.trace(
+				'Validation issues: %s',
+				JSON.stringify(validationResult.error.issues, null, 2)
+			);
+			tui.fatal(
+				`Failed to update workspace: ${formatWorkspaceValidationMessage(validationResult.error.issues)}`,
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		try {
+			const updated = await client.updateWorkspace(args.workspaceId, validationResult.data);
+
+			if (options.json) {
+				return updated;
+			}
+
+			tui.success(`Workspace ${updated.id} updated.`);
+			tui.newline();
+			printWorkspaceSummary(updated);
+			return updated;
+		} catch (err) {
+			if (err instanceof ValidationInputError || err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+				tui.fatal(
+					`Failed to update workspace: ${formatWorkspaceValidationMessage(err.issues)}`,
+					ErrorCode.VALIDATION_FAILED
+				);
+			}
+			if (err instanceof APIError && err.status >= 400 && err.status < 500) {
+				tui.fatal(`Failed to update workspace: ${err.message}`, ErrorCode.VALIDATION_FAILED);
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to update workspace: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});

package/src/cmd/coder/workspace/validate-dependencies.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { APIError, ValidationOutputError } from '@agentuity/core';
+import { CoderClient } from '@agentuity/core/coder';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { parseCommaList } from './common';
+
+export const validateWorkspaceDependenciesSubcommand = createSubcommand({
+	name: 'validate-dependencies',
+	aliases: ['validate-deps'],
+	description: 'Validate APT dependencies for Coder workspace snapshots',
+	tags: ['read-only', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder workspace validate-dependencies git,nodejs'),
+			description: 'Validate dependency package names',
+		},
+	],
+	schema: {
+		args: z.object({
+			dependencies: z.string().describe('Comma-separated APT dependencies to validate'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const dependencies = parseCommaList(args.dependencies);
+		if (dependencies.length === 0) {
+			tui.fatal('At least one dependency is required.', ErrorCode.VALIDATION_FAILED);
+		}
+
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		try {
+			const result = await client.validateWorkspaceDependencies(dependencies);
+			if (options.json) {
+				return result;
+			}
+
+			if (result.valid.length > 0) {
+				tui.success(`Valid dependencies: ${result.valid.join(', ')}`);
+			}
+			if (result.invalid.length > 0) {
+				tui.error(`Invalid dependencies: ${result.invalid.length}`);
+				for (const invalid of result.invalid) {
+					tui.output(`  - ${invalid.package}: ${invalid.error}`);
+				}
+			}
+			return result;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			if (err instanceof APIError && err.status >= 400 && err.status < 500) {
+				tui.fatal(
+					`Failed to validate dependencies: ${err.message}`,
+					ErrorCode.VALIDATION_FAILED
+				);
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to validate dependencies: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});