@agentuity/cli 0.0.47 → 0.0.49

package/src/cmd/cloud/deploy.ts

@@ -27,12 +27,45 @@ import {
 import { zipDir } from '../../utils/zip';
 import { encryptFIPSKEMDEMStream } from '../../crypto/box';
 import { checkCustomDomainForDNS } from './domain';
+import { getCommand } from '../../command-prefix';
+import { z } from 'zod';
+
+const DeployResponseSchema = z.object({
+	success: z.boolean().describe('Whether deployment succeeded'),
+	deploymentId: z.string().describe('Deployment ID'),
+	projectId: z.string().describe('Project ID'),
+	urls: z
+		.object({
+			deployment: z.string().describe('Deployment-specific URL'),
+			latest: z.string().describe('Latest/active deployment URL'),
+			custom: z.array(z.string()).optional().describe('Custom domain URLs'),
+		})
+		.optional()
+		.describe('Deployment URLs'),
+});
 
 export const deploySubcommand = createSubcommand({
 	name: 'deploy',
 	description: 'Deploy project to the Agentuity Cloud',
+	tags: [
+		'mutating',
+		'creates-resource',
+		'slow',
+		'api-intensive',
+		'requires-auth',
+		'requires-project',
+	],
+	examples: [
+		`${getCommand('cloud deploy')}                    # Deploy current project`,
+		`${getCommand('cloud deploy')} --log-level=debug  # Deploy with verbose output`,
+	],
 	toplevel: true,
+	idempotent: false,
 	requires: { auth: true, project: true, apiClient: true },
+	prerequisites: ['auth login'],
+	schema: {
+		response: DeployResponseSchema,
+	},
 
 	async handler(ctx) {
 		const { project, apiClient, projectDir, config, options } = ctx;
@@ -183,6 +216,12 @@ export const deploySubcommand = createSubcommand({
 									if (relative.endsWith('.map')) {
 										return false;
 									}
+									// ignore common stuff we never want to include in the zip
+									if (relative.startsWith('.env')) return false;
+									if (relative.startsWith('.git/')) return false;
+									if (relative.startsWith('.ssh/')) return false;
+									if (relative.startsWith('node_modules/')) return false;
+									if (relative === '.DS_Store') return false;
 									return true;
 								},
 							});
@@ -329,6 +368,27 @@ export const deploySubcommand = createSubcommand({
 					);
 				}
 			}
+
+			// Return deployment result (if available)
+			if (deployment && complete?.publicUrls) {
+				return {
+					success: true,
+					deploymentId: deployment.id,
+					projectId: project.projectId,
+					urls: {
+						deployment: complete.publicUrls.deployment,
+						latest: complete.publicUrls.latest,
+						custom: complete.publicUrls.custom,
+					},
+				};
+			}
+
+			// Fallback response
+			return {
+				success: false,
+				deploymentId: '',
+				projectId: project.projectId,
+			};
 		} catch (ex) {
 			tui.fatal(`unexpected error trying to deploy project. ${ex}`);
 		}

package/src/cmd/cloud/deployment/index.ts

@@ -0,0 +1,20 @@
+import { createCommand } from '../../../types';
+import { listSubcommand } from './list';
+import { showSubcommand } from './show';
+import { removeSubcommand } from './remove';
+import { rollbackSubcommand } from './rollback';
+import { undeploySubcommand } from './undeploy';
+
+export const deploymentCommand = createCommand({
+	name: 'deployment',
+	description: 'Manage deployments',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	aliases: ['deployments', 'dep'],
+	subcommands: [
+		listSubcommand,
+		showSubcommand,
+		removeSubcommand,
+		rollbackSubcommand,
+		undeploySubcommand,
+	],
+});

package/src/cmd/cloud/deployment/list.ts

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectDeploymentList } from '@agentuity/server';
+import { resolveProjectId } from './utils';
+import { Table } from 'console-table-printer';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+const DeploymentListResponseSchema = z.array(
+	z.object({
+		id: z.string().describe('Deployment ID'),
+		state: z.string().optional().describe('Current state of the deployment'),
+		active: z.boolean().describe('Whether this is the active deployment'),
+		createdAt: z.string().describe('Creation timestamp'),
+		message: z.string().optional().describe('Deployment message or description'),
+		tags: z.array(z.string()).describe('Deployment tags'),
+	})
+);
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	description: 'List deployments',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	examples: [
+		`${getCommand('cloud deployment list')}           # List 10 most recent deployments`,
+		`${getCommand('cloud deployment list')} --count=25 # List 25 most recent deployments`,
+		`${getCommand('cloud deployment list')} --project-id=proj_abc123xyz`,
+	],
+	aliases: ['ls'],
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
+	idempotent: true,
+	pagination: {
+		supported: true,
+		defaultLimit: 10,
+		maxLimit: 100,
+		parameters: {
+			limit: 'count',
+		},
+	},
+	schema: {
+		options: z.object({
+			'project-id': z.string().optional().describe('Project ID'),
+			count: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.max(100)
+				.default(10)
+				.describe('Number of deployments to list (1–100)'),
+		}),
+		response: DeploymentListResponseSchema,
+	},
+	async handler(ctx) {
+		const projectId = resolveProjectId(ctx, { projectId: ctx.opts['project-id'] });
+		const { apiClient, opts } = ctx;
+
+		try {
+			const deployments = await projectDeploymentList(apiClient, projectId, opts.count);
+
+			if (deployments.length === 0) {
+				tui.info('No deployments found.');
+				return [];
+			}
+
+			const table = new Table({
+				columns: [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'State', alignment: 'left' },
+					{ name: 'Active', alignment: 'center' },
+					{ name: 'Created', alignment: 'left' },
+					{ name: 'Message', alignment: 'left' },
+					{ name: 'Tags', alignment: 'left' },
+				],
+			});
+
+			for (const d of deployments) {
+				table.addRow({
+					ID: d.id,
+					State: d.state || 'unknown',
+					Active: d.active ? 'Yes' : '',
+					Created: new Date(d.createdAt).toLocaleString(),
+					Message: d.message || '',
+					Tags: d.tags.join(', '),
+				});
+			}
+			table.printTable();
+
+			return deployments.map((d) => ({
+				id: d.id,
+				state: d.state,
+				active: d.active,
+				createdAt: d.createdAt,
+				message: d.message,
+				tags: d.tags,
+			}));
+		} catch (ex) {
+			tui.fatal(
+				`Failed to list deployments: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});

package/src/cmd/cloud/deployment/remove.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectDeploymentDelete } from '@agentuity/server';
+import { resolveProjectId } from './utils';
+import { getCommand } from '../../../command-prefix';
+
+const DeploymentRemoveResponseSchema = z.object({
+	success: z.boolean().describe('Whether the removal succeeded'),
+	projectId: z.string().describe('Project ID'),
+	deploymentId: z.string().describe('Deployment ID that was removed'),
+});
+
+export const removeSubcommand = createSubcommand({
+	name: 'remove',
+	description: 'Remove a specific deployment',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth', 'requires-deployment'],
+	examples: [
+		`${getCommand('cloud deployment remove')} dep_abc123xyz        # Remove with confirmation`,
+		`${getCommand('cloud deployment remove')} dep_abc123xyz --force # Remove without confirmation`,
+		`${getCommand('cloud deployment remove')} deployment-2024-11-20 --project-id=proj_abc123xyz`,
+	],
+	aliases: ['rm', 'delete'],
+	idempotent: false,
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
+	prerequisites: ['cloud deploy'],
+	schema: {
+		args: z.object({
+			deployment_id: z.string().describe('Deployment ID'),
+		}),
+		options: z.object({
+			'project-id': z.string().optional().describe('Project ID'),
+			force: z.boolean().default(false).describe('Force removal without confirmation'),
+		}),
+		response: DeploymentRemoveResponseSchema,
+	},
+	async handler(ctx) {
+		const projectId = resolveProjectId(ctx, { projectId: ctx.opts['project-id'] });
+		const { apiClient, args, opts } = ctx;
+
+		if (!opts.force) {
+			const confirmed = await tui.confirm(
+				`Are you sure you want to remove deployment ${args.deployment_id}?`
+			);
+			if (!confirmed) {
+				tui.info('Operation cancelled');
+				return { success: false, projectId, deploymentId: args.deployment_id };
+			}
+		}
+
+		try {
+			await projectDeploymentDelete(apiClient, projectId, args.deployment_id);
+			tui.success(`Deployment ${args.deployment_id} removed successfully.`);
+
+			return {
+				success: true,
+				projectId,
+				deploymentId: args.deployment_id,
+			};
+		} catch (ex) {
+			tui.fatal(`Failed to remove deployment: ${ex instanceof Error ? ex.message : String(ex)}`);
+		}
+	},
+});

package/src/cmd/cloud/deployment/rollback.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectDeploymentRollback, projectDeploymentList } from '@agentuity/server';
+import { resolveProjectId } from './utils';
+import { getCommand } from '../../../command-prefix';
+
+const DeploymentRollbackResponseSchema = z.object({
+	success: z.boolean().describe('Whether the rollback succeeded'),
+	projectId: z.string().describe('Project ID'),
+	targetDeploymentId: z.string().describe('Deployment ID that was rolled back to'),
+});
+
+export const rollbackSubcommand = createSubcommand({
+	name: 'rollback',
+	description: 'Rollback the latest to the previous deployment',
+	tags: [
+		'destructive',
+		'deletes-resource',
+		'updates-resource',
+		'slow',
+		'api-intensive',
+		'requires-auth',
+		'requires-deployment',
+	],
+	examples: [
+		`${getCommand('cloud deployment rollback')}                   # Rollback to previous deployment`,
+		`${getCommand('cloud deployment rollback')} --project-id=proj_abc123xyz`,
+	],
+	idempotent: false,
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
+	prerequisites: ['cloud deploy'],
+	schema: {
+		options: z.object({
+			'project-id': z.string().optional().describe('Project ID'),
+		}),
+		response: DeploymentRollbackResponseSchema,
+	},
+	async handler(ctx) {
+		const projectId = resolveProjectId(ctx, { projectId: ctx.opts['project-id'] });
+		const { apiClient } = ctx;
+
+		try {
+			// Fetch deployments to find the previous one
+			const deployments = await projectDeploymentList(apiClient, projectId, 5);
+
+			// Find currently active
+			const activeIndex = deployments.findIndex((d) => d.active);
+
+			let targetDeploymentId: string | undefined;
+
+			if (activeIndex === -1) {
+				// No active deployment.
+				const candidate = deployments.find((d) => d.state === 'completed');
+				targetDeploymentId = candidate?.id;
+			} else {
+				// Has active deployment. Find the next completed one.
+				const candidate = deployments
+					.slice(activeIndex + 1)
+					.find((d) => d.state === 'completed');
+				targetDeploymentId = candidate?.id;
+			}
+
+			if (!targetDeploymentId) {
+				tui.fatal('No previous completed deployment found to rollback to.');
+			}
+
+			const confirmed = await tui.confirm(`Rollback to deployment ${targetDeploymentId}?`);
+			if (!confirmed) {
+				tui.info('Operation cancelled');
+				return { success: false, projectId, targetDeploymentId };
+			}
+
+			await projectDeploymentRollback(apiClient, projectId, targetDeploymentId!);
+			tui.success(`Rolled back to deployment ${targetDeploymentId}.`);
+
+			return {
+				success: true,
+				projectId,
+				targetDeploymentId,
+			};
+		} catch (ex) {
+			tui.fatal(`Failed to rollback: ${ex instanceof Error ? ex.message : String(ex)}`);
+		}
+	},
+});

package/src/cmd/cloud/deployment/show.ts

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectDeploymentGet } from '@agentuity/server';
+import { resolveProjectId } from './utils';
+import { getCommand } from '../../../command-prefix';
+
+const DeploymentShowResponseSchema = z.object({
+	id: z.string().describe('Deployment ID'),
+	state: z.string().optional().describe('Deployment state'),
+	active: z.boolean().describe('Whether deployment is active'),
+	createdAt: z.string().describe('Creation timestamp'),
+	updatedAt: z.string().optional().describe('Last update timestamp'),
+	message: z.string().optional().describe('Deployment message'),
+	tags: z.array(z.string()).describe('Deployment tags'),
+	customDomains: z.array(z.string()).optional().describe('Custom domains'),
+	cloudRegion: z.string().optional().describe('Cloud region'),
+	metadata: z.any().optional().describe('Deployment metadata'),
+});
+
+export const showSubcommand = createSubcommand({
+	name: 'show',
+	description: 'Show details about a specific deployment',
+	tags: ['read-only', 'fast', 'requires-auth', 'requires-deployment'],
+	examples: [
+		`${getCommand('cloud deployment show')} dep_abc123xyz`,
+		`${getCommand('cloud deployment show')} deployment-2024-11-20 --project-id=proj_abc123xyz`,
+	],
+	aliases: ['get'],
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
+	prerequisites: ['cloud deploy'],
+	schema: {
+		args: z.object({
+			deployment_id: z.string().describe('Deployment ID'),
+		}),
+		options: z.object({
+			'project-id': z.string().optional().describe('Project ID'),
+		}),
+		response: DeploymentShowResponseSchema,
+	},
+	idempotent: true,
+	async handler(ctx) {
+		const projectId = resolveProjectId(ctx, { projectId: ctx.opts['project-id'] });
+		const { apiClient, args } = ctx;
+
+		try {
+			const deployment = await projectDeploymentGet(apiClient, projectId, args.deployment_id);
+
+			tui.banner(`Deployment ${deployment.id}`, `State: ${deployment.state || 'unknown'}`);
+
+			console.log(tui.bold('ID:       ') + deployment.id);
+			console.log(tui.bold('Project:  ') + projectId);
+			console.log(tui.bold('State:    ') + (deployment.state || 'unknown'));
+			console.log(tui.bold('Active:   ') + (deployment.active ? 'Yes' : 'No'));
+			console.log(tui.bold('Created:  ') + new Date(deployment.createdAt).toLocaleString());
+			if (deployment.updatedAt) {
+				console.log(tui.bold('Updated:  ') + new Date(deployment.updatedAt).toLocaleString());
+			}
+			if (deployment.message) {
+				console.log(tui.bold('Message:  ') + deployment.message);
+			}
+			if (deployment.tags.length > 0) {
+				console.log(tui.bold('Tags:     ') + deployment.tags.join(', '));
+			}
+			if (deployment.customDomains && deployment.customDomains.length > 0) {
+				console.log(tui.bold('Domains:  ') + deployment.customDomains.join(', '));
+			}
+			if (deployment.cloudRegion) {
+				console.log(tui.bold('Region:   ') + deployment.cloudRegion);
+			}
+
+			// Metadata
+			const origin = deployment.metadata?.origin;
+			if (origin?.commit) {
+				tui.newline();
+				tui.info('Origin Information');
+				if (origin.trigger) console.log(`  Trigger:  ${origin.trigger}`);
+				if (origin.provider) console.log(`  Provider: ${origin.provider}`);
+				if (origin.event) console.log(`  Event:    ${origin.event}`);
+				if (origin.branch) console.log(`  Branch:   ${origin.branch}`);
+
+				if (origin.commit) {
+					console.log(`  Commit:   ${origin.commit.hash}`);
+					if (origin.commit.message) console.log(`  Message:  ${origin.commit.message}`);
+					if (origin.commit.author?.name)
+						console.log(`  Author:   ${origin.commit.author.name}`);
+				}
+			}
+
+			return {
+				id: deployment.id,
+				state: deployment.state,
+				active: deployment.active,
+				createdAt: deployment.createdAt,
+				updatedAt: deployment.updatedAt,
+				message: deployment.message,
+				tags: deployment.tags,
+				customDomains: deployment.customDomains,
+				cloudRegion: deployment.cloudRegion,
+				metadata: deployment.metadata,
+			};
+		} catch (ex) {
+			tui.fatal(`Failed to show deployment: ${ex instanceof Error ? ex.message : String(ex)}`);
+		}
+	},
+});

package/src/cmd/cloud/deployment/undeploy.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectDeploymentUndeploy } from '@agentuity/server';
+import { resolveProjectId } from './utils';
+import { getCommand } from '../../../command-prefix';
+
+export const undeploySubcommand = createSubcommand({
+	name: 'undeploy',
+	description: 'Undeploy the latest deployment',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth', 'requires-deployment'],
+	examples: [
+		`${getCommand('cloud deployment undeploy')}        # Undeploy with confirmation`,
+		`${getCommand('cloud deployment undeploy')} --force # Undeploy without confirmation`,
+		`${getCommand('cloud deployment undeploy')} --project-id=proj_abc123xyz`,
+	],
+	idempotent: false,
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
+	prerequisites: ['cloud deploy'],
+	schema: {
+		options: z.object({
+			'project-id': z.string().optional().describe('Project ID'),
+			force: z.boolean().default(false).describe('Force undeploy without confirmation'),
+		}),
+	},
+	async handler(ctx) {
+		const projectId = resolveProjectId(ctx, { projectId: ctx.opts['project-id'] });
+		const { apiClient, opts } = ctx;
+
+		if (!opts.force) {
+			const confirmed = await tui.confirm(
+				'Are you sure you want to undeploy? This will stop the active deployment.'
+			);
+			if (!confirmed) {
+				tui.info('Operation cancelled');
+				return;
+			}
+		}
+
+		try {
+			await projectDeploymentUndeploy(apiClient, projectId);
+			tui.success('Undeployed successfully.');
+		} catch (ex) {
+			tui.fatal(`Failed to undeploy: ${ex instanceof Error ? ex.message : String(ex)}`);
+		}
+	},
+});

package/src/cmd/cloud/deployment/utils.ts

@@ -0,0 +1,14 @@
+import { ProjectConfig } from '../../../types';
+
+export function resolveProjectId(
+	ctx: { project?: ProjectConfig },
+	options: { projectId?: string }
+): string {
+	if (options.projectId) {
+		return options.projectId;
+	}
+	if (ctx.project?.projectId) {
+		return ctx.project.projectId;
+	}
+	throw new Error('Project ID is required. Use --project-id or run from a project directory.');
+}

package/src/cmd/cloud/domain.ts

@@ -23,8 +23,9 @@ export async function checkCustomDomainForDNS(
 ): Promise<DNSResult[]> {
 	const suffix = config?.overrides?.api_url?.includes('agentuity.io')
 		? 'agentuity.io'
-		: 'agentuity.com';
-	const id = Bun.hash.xxHash64(`${projectId}latest`).toString(16);
+		: 'agentuity.cloud';
+	// FIXME: update to add the region into this
+	const id = Bun.hash.xxHash64(projectId).toString(16);
 	const proxy = `p${id}.${suffix}`;
 
 	return Promise.all(

package/src/cmd/cloud/index.ts

@@ -3,9 +3,17 @@ import { deploySubcommand } from './deploy';
 import { resourceSubcommand } from './resource';
 import { sshSubcommand } from './ssh';
 import { scpSubcommand } from './scp';
+import { deploymentCommand } from './deployment';
 
 export const command = createCommand({
 	name: 'cloud',
 	description: 'Cloud related commands',
-	subcommands: [deploySubcommand, resourceSubcommand, sshSubcommand, scpSubcommand],
+	tags: ['slow', 'requires-auth'],
+	subcommands: [
+		deploySubcommand,
+		resourceSubcommand,
+		sshSubcommand,
+		scpSubcommand,
+		deploymentCommand,
+	],
 });

package/src/cmd/cloud/resource/add.ts

@@ -4,16 +4,30 @@ import enquirer from 'enquirer';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { getCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
 
 export const addSubcommand = createSubcommand({
 	name: 'add',
 	aliases: ['create'],
 	description: 'Add a cloud resource for an organization',
+	tags: ['mutating', 'creates-resource', 'slow', 'requires-auth', 'requires-deployment'],
+	idempotent: false,
 	requires: { auth: true, org: true, region: true },
+	examples: [
+		getCommand('cloud resource add'),
+		getCommand('cloud resource add --type database'),
+		getCommand('cloud resource add --type storage'),
+		getCommand('cloud resource create --type database'),
+	],
 	schema: {
 		options: z.object({
 			type: z.enum(['database', 'storage']).optional().describe('Resource type'),
 		}),
+		response: z.object({
+			success: z.boolean().describe('Whether creation succeeded'),
+			type: z.string().describe('Resource type (database or storage)'),
+			name: z.string().describe('Created resource name'),
+		}),
 	},
 
 	async handler(ctx) {
@@ -49,6 +63,11 @@ export const addSubcommand = createSubcommand({
 
 		if (created.length > 0) {
 			tui.success(`Created ${resourceType}: ${tui.bold(created[0].name)}`);
+			return {
+				success: true,
+				type: resourceType,
+				name: created[0].name,
+			};
 		} else {
 			tui.fatal('Failed to create resource');
 		}

package/src/cmd/cloud/resource/delete.ts

@@ -4,18 +4,33 @@ import enquirer from 'enquirer';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { getCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	description: 'Delete cloud resource(s) for an organization',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth', 'requires-deployment'],
 	aliases: ['rm', 'del', 'remove'],
+	idempotent: false,
 	requires: { auth: true, org: true, region: true },
+	examples: [
+		getCommand('cloud resource delete'),
+		getCommand('cloud resource delete --type db --name my-database'),
+		getCommand('cloud resource delete --type s3 --name uploads'),
+		getCommand('--explain cloud resource delete --type db --name old-db'),
+		getCommand('--dry-run cloud resource rm --type s3 --name temp-bucket'),
+	],
 	schema: {
 		options: z.object({
 			type: z.enum(['db', 's3']).optional().describe('Resource type (db or s3)'),
 			name: z.string().optional().describe('Resource name to delete'),
 			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
 		}),
+		response: z.object({
+			success: z.boolean().describe('Whether deletion succeeded'),
+			count: z.number().describe('Number of resources deleted'),
+			resources: z.array(z.string()).describe('Deleted resource names'),
+		}),
 	},
 
 	async handler(ctx) {
@@ -41,7 +56,7 @@ export const deleteSubcommand = createSubcommand({
 
 			if (resources.db.length === 0 && resources.s3.length === 0) {
 				tui.info('No resources found to delete');
-				return;
+				return { success: false, count: 0, resources: [] };
 			}
 
 			// Build choices for multi-select and resource map
@@ -81,7 +96,7 @@ export const deleteSubcommand = createSubcommand({
 
 		if (resourcesToDelete.length === 0) {
 			tui.info('No resources selected for deletion');
-			return;
+			return { success: false, count: 0, resources: [] };
 		}
 
 		// Confirm deletion
@@ -98,7 +113,7 @@ export const deleteSubcommand = createSubcommand({
 
 			if (!confirm.confirm) {
 				tui.info('Deletion cancelled');
-				return;
+				return { success: false, count: 0, resources: [] };
 			}
 		}
 
@@ -116,5 +131,11 @@ export const deleteSubcommand = createSubcommand({
 		} else {
 			tui.error('Failed to delete resources');
 		}
+
+		return {
+			success: deleted.length > 0,
+			count: deleted.length,
+			resources: deleted,
+		};
 	},
 });