@agentuity/cli 0.0.48 → 0.0.49

package/src/cmd/objectstore/repl.ts

@@ -0,0 +1,235 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import { createRepl, type ReplCommand } from '../../repl';
+import { showBanner } from '../../banner';
+import * as tui from '../../tui';
+import { isPossiblyJSON, tryParseJSON } from '../../json';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../command-prefix';
+
+export const replSubcommand = createCommand({
+	name: 'repl',
+	description: 'Start an interactive repl for working with object storage',
+	tags: ['slow', 'requires-auth'],
+	idempotent: false,
+	requires: { auth: true, project: true },
+	examples: [`${getCommand('objectstore repl')} - Start interactive object storage session`],
+
+	async handler(ctx) {
+		showBanner(undefined, true);
+		tui.info('Managing object store for project');
+		tui.newline();
+		console.log(tui.bold('Org:'.padEnd(10, ' ')), ' ', tui.muted(ctx.project.orgId));
+		console.log(tui.bold('Project:'.padEnd(10, ' ')), ' ', tui.muted(ctx.project.projectId));
+		tui.newline();
+
+		const storage = await createStorageAdapter(ctx);
+
+		const commands: ReplCommand[] = [
+			{
+				name: 'put',
+				description: 'Put an object into a bucket',
+				schema: {
+					args: z.tuple([z.string().min(1), z.string().min(1), z.string().min(1)]),
+					argNames: ['bucket', 'key', 'value'],
+				},
+				handler: async (ctx) => {
+					ctx.setProgress('saving');
+					const started = Date.now();
+					const contentType = isPossiblyJSON(ctx.parsed.args[2]!)
+						? 'application/json'
+						: 'text/plain';
+					const data = new TextEncoder().encode(ctx.parsed.args[2]!);
+					await storage.put(ctx.parsed.args[0]!, ctx.parsed.args[1]!, data, {
+						contentType,
+					});
+					ctx.success(`saved in ${(Date.now() - started).toFixed(1)}ms (${contentType})`);
+				},
+			},
+			{
+				name: 'get',
+				description: 'Get an object from a bucket',
+				schema: {
+					args: z.tuple([z.string().min(1), z.string().min(1)]),
+					argNames: ['bucket', 'key'],
+				},
+				handler: async (ctx) => {
+					ctx.setProgress('fetching');
+					const started = Date.now();
+					const res = await storage.get(ctx.parsed.args[0]!, ctx.parsed.args[1]!);
+					if (res.exists) {
+						if (res.data) {
+							if (res.contentType?.includes('json')) {
+								const val = tryParseJSON(new TextDecoder().decode(res.data));
+								ctx.json(val);
+							} else if (res.contentType?.includes('text')) {
+								ctx.write(new TextDecoder().decode(res.data));
+							} else {
+								ctx.info(`Read ${res.data.byteLength} bytes (${res.contentType})`);
+							}
+							ctx.success(
+								`retrieved in ${(Date.now() - started).toFixed(1)}ms (${res.contentType})`
+							);
+						} else {
+							ctx.warning(
+								`${ctx.parsed.args[1]!} returned empty data for bucket ${ctx.parsed.args[0]!}`
+							);
+						}
+					} else {
+						ctx.warning(
+							`${ctx.parsed.args[1]!} does not exist in bucket ${ctx.parsed.args[0]!}`
+						);
+					}
+				},
+			},
+			{
+				name: 'delete',
+				aliases: ['rm', 'remove', 'del'],
+				description: 'Delete an object from a bucket',
+				schema: {
+					args: z.tuple([z.string().min(1), z.string().min(1)]),
+					argNames: ['bucket', 'key'],
+				},
+				handler: async (ctx) => {
+					ctx.setProgress('deleting');
+					const started = Date.now();
+					const deleted = await storage.delete(ctx.parsed.args[0]!, ctx.parsed.args[1]!);
+					if (deleted) {
+						ctx.success(`deleted in ${(Date.now() - started).toFixed(1)}ms`);
+					} else {
+						ctx.warning(
+							`${ctx.parsed.args[1]!} did not exist in bucket ${ctx.parsed.args[0]!}`
+						);
+					}
+				},
+			},
+			{
+				name: 'url',
+				aliases: ['publicurl', 'presigned'],
+				description: 'Create a public URL for an object',
+				schema: {
+					args: z.tuple([
+						z.string().min(1),
+						z.string().min(1),
+						z.coerce.number().min(60).optional(),
+					]),
+					argNames: ['bucket', 'key', 'expires'],
+				},
+				handler: async (ctx) => {
+					ctx.setProgress('creating url');
+					const started = Date.now();
+					const expires =
+						ctx.parsed.args.length > 2 ? parseInt(ctx.parsed.args[2]!) : undefined;
+					const url = await storage.createPublicURL(
+						ctx.parsed.args[0]!,
+						ctx.parsed.args[1]!,
+						expires ? { expiresDuration: expires } : undefined
+					);
+					ctx.write(url);
+					ctx.success(`created in ${(Date.now() - started).toFixed(1)}ms`);
+				},
+			},
+			{
+				name: 'list-buckets',
+				aliases: ['buckets', 'lb'],
+				description: 'List all buckets',
+				handler: async (ctx) => {
+					ctx.setProgress('listing buckets');
+					const started = Date.now();
+					const buckets = await storage.listBuckets();
+					if (buckets.length === 0) {
+						ctx.info('No buckets found');
+					} else {
+						ctx.info(`Found ${buckets.length} bucket(s):`);
+						for (const bucket of buckets) {
+							const sizeMB = (bucket.total_bytes / (1024 * 1024)).toFixed(2);
+							ctx.write(
+								`  ${tui.bold(bucket.name)}: ${bucket.object_count} objects, ${sizeMB} MB`
+							);
+						}
+					}
+					ctx.success(`retrieved in ${(Date.now() - started).toFixed(1)}ms`);
+				},
+			},
+			{
+				name: 'list-keys',
+				aliases: ['keys', 'ls'],
+				description: 'List all keys in a bucket',
+				schema: {
+					args: z.tuple([z.string().min(1)]),
+					argNames: ['bucket'],
+				},
+				handler: async (ctx) => {
+					ctx.setProgress('listing keys');
+					const started = Date.now();
+					const objects = await storage.listKeys(ctx.parsed.args[0]!);
+					if (objects.length === 0) {
+						ctx.info(`No objects found in bucket ${tui.bold(ctx.parsed.args[0]!)}`);
+					} else {
+						ctx.info(
+							`Found ${objects.length} object(s) in ${tui.bold(ctx.parsed.args[0]!)}:`
+						);
+						for (const obj of objects) {
+							const sizeMB = (obj.size / (1024 * 1024)).toFixed(2);
+							const date = new Date(obj.updated_at).toLocaleString();
+							ctx.write(`  ${tui.bold(obj.key)}: ${sizeMB} MB, updated ${date}`);
+						}
+					}
+					ctx.success(`retrieved in ${(Date.now() - started).toFixed(1)}ms`);
+				},
+			},
+			{
+				name: 'delete-bucket',
+				aliases: ['rmbucket', 'delbucket'],
+				description: 'Delete a bucket and all its contents',
+				schema: {
+					args: z.tuple([z.string().min(1)]),
+					argNames: ['bucket'],
+				},
+				handler: async (ctx) => {
+					ctx.warning(
+						`This will delete bucket ${tui.bold(ctx.parsed.args[0]!)} and ALL its contents.`
+					);
+					const confirm = await new Promise<boolean>((resolve) => {
+						process.stdout.write('Are you sure? (yes/no): ');
+						process.stdin.once('data', (data) => {
+							const answer = data.toString().trim().toLowerCase();
+							resolve(answer === 'yes' || answer === 'y');
+						});
+					});
+					if (!confirm) {
+						ctx.info('Cancelled');
+						return;
+					}
+					ctx.setProgress('deleting bucket');
+					const started = Date.now();
+					const deleted = await storage.deleteBucket(ctx.parsed.args[0]!);
+					if (deleted) {
+						ctx.success(`deleted in ${(Date.now() - started).toFixed(1)}ms`);
+					} else {
+						ctx.warning(`Bucket ${tui.bold(ctx.parsed.args[0]!)} not found`);
+					}
+				},
+			},
+			{
+				name: 'exit',
+				aliases: ['quit'],
+				description: 'Exit the repl',
+				handler: async (ctx) => {
+					return ctx.exit();
+				},
+			},
+		];
+
+		// Start the REPL
+		await createRepl({
+			name: 'objectstore',
+			prompt: '> ',
+			welcome: tui.muted('Type "help" or / for available commands.'),
+			exitMessage: 'Goodbye!',
+			commands,
+		});
+	},
+});
+
+export default replSubcommand;

package/src/cmd/objectstore/url.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import * as tui from '../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../command-prefix';
+
+const ObjectStoreURLResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	bucket: z.string().describe('Bucket name'),
+	key: z.string().describe('Object key'),
+	url: z.string().describe('Public or presigned URL'),
+	expires: z.number().optional().describe('URL expiration time in seconds'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+export const urlSubcommand = createCommand({
+	name: 'url',
+	aliases: ['publicurl', 'presigned'],
+	description: 'Create a public URL for an object',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, project: true },
+	idempotent: true,
+	examples: [
+		`${getCommand('objectstore url uploads images/logo.png')} - Get public URL for logo`,
+		`${getCommand('objectstore url assets data/export.json --expires 3600')} - Get 1h temporary URL`,
+		`${getCommand('objectstore presigned backups db-2024.sql --expires 300')} - Get 5m presigned URL`,
+	],
+	schema: {
+		args: z.object({
+			bucket: z.string().min(1).describe('the bucket name'),
+			key: z.string().min(1).describe('the key name'),
+			expires: z.coerce.number().min(60).optional().describe('the expiration in seconds'),
+		}),
+		response: ObjectStoreURLResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+		const url = await storage.createPublicURL(args.bucket, args.key, {
+			expiresDuration: args.expires,
+		});
+		const durationMs = Date.now() - started;
+		console.log(url);
+		tui.success(`created in ${durationMs.toFixed(1)}ms`);
+
+		return {
+			success: true,
+			bucket: args.bucket,
+			key: args.key,
+			url,
+			expires: args.expires,
+			durationMs,
+		};
+	},
+});
+
+export default urlSubcommand;

package/src/cmd/objectstore/util.ts

@@ -0,0 +1,28 @@
+import { Logger, ObjectStorageService } from '@agentuity/core';
+import { createServerFetchAdapter } from '@agentuity/server';
+import { loadProjectSDKKey } from '../../config';
+import type { Config } from '../../types';
+import * as tui from '../../tui';
+
+export async function createStorageAdapter(ctx: {
+	logger: Logger;
+	projectDir: string;
+	config: Config | null;
+}) {
+	const sdkKey = await loadProjectSDKKey(ctx.projectDir);
+	if (!sdkKey) {
+		tui.fatal(`Couldn't find the AGENTUITY_SDK_KEY in ${ctx.projectDir} .env file`);
+	}
+
+	const adapter = createServerFetchAdapter(
+		{
+			headers: {
+				Authorization: `Bearer ${sdkKey}`,
+			},
+		},
+		ctx.logger
+	);
+
+	const baseUrl = ctx.config?.overrides?.object_url ?? 'https://catalyst.agentuity.cloud';
+	return new ObjectStorageService(baseUrl, adapter);
+}

package/src/cmd/profile/create.ts

@@ -12,13 +12,22 @@ import {
 	saveProfile,
 } from '../../config';
 import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
 
 const PROFILE_NAME_REGEX = /^[\w_-]{3,}$/;
 
 export const createCommand = createSubcommand({
 	name: 'create',
 	description: 'Create a new configuration profile',
+	tags: ['mutating', 'creates-resource', 'fast'],
 	aliases: ['new'],
+	idempotent: false,
+	examples: [
+		getCommand('profile create production'),
+		getCommand('profile create staging --switch'),
+		getCommand('profile create development'),
+	],
 	schema: {
 		args: z
 			.object({
@@ -32,6 +41,11 @@ export const createCommand = createSubcommand({
 		options: z.object({
 			switch: z.boolean().optional().describe('switch to this profile (if more than one)'),
 		}),
+		response: z.object({
+			success: z.boolean().describe('Whether creation succeeded'),
+			name: z.string().describe('Profile name'),
+			path: z.string().describe('Profile file path'),
+		}),
 	},
 
 	async handler(ctx) {
@@ -42,7 +56,10 @@ export const createCommand = createSubcommand({
 		const existing = profiles.find((p) => p.name === name);
 
 		if (existing) {
-			return logger.fatal(`Profile "${name}" already exists at ${existing.filename}`);
+			return logger.fatal(
+				`Profile "${name}" already exists at ${existing.filename}`,
+				ErrorCode.RESOURCE_ALREADY_EXISTS
+			);
 		}
 
 		await ensureConfigDir();
@@ -77,10 +94,19 @@ export const createCommand = createSubcommand({
 			}
 
 			tui.success(`Created profile "${name}" at ${filename}`);
+
+			return {
+				success: true,
+				name,
+				path: filename,
+			};
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			const stack = error instanceof Error ? error.stack : undefined;
-			logger.fatal(`Failed to create profile: ${message}${stack ? `\n${stack}` : ''}`);
+			logger.fatal(
+				`Failed to create profile: ${message}${stack ? `\n${stack}` : ''}`,
+				ErrorCode.INTERNAL_ERROR
+			);
 		}
 	},
 });

package/src/cmd/profile/delete.ts

@@ -3,11 +3,20 @@ import { z } from 'zod';
 import { fetchProfiles } from '../../config';
 import { unlink } from 'node:fs/promises';
 import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
 
 export const deleteCommand = createSubcommand({
 	name: 'delete',
 	description: 'Delete a configuration profile',
+	tags: ['destructive', 'deletes-resource', 'fast'],
+	idempotent: false,
 	aliases: ['remove', 'rm', 'del'],
+	examples: [
+		getCommand('profile delete staging'),
+		getCommand('profile delete old-dev --confirm'),
+		getCommand('profile delete'),
+	],
 	schema: {
 		args: z.object({
 			name: z.string().optional().describe('The name of the profile to delete'),
@@ -15,6 +24,10 @@ export const deleteCommand = createSubcommand({
 		options: z.object({
 			confirm: z.boolean().optional().describe('Skip confirmation prompt'),
 		}),
+		response: z.object({
+			success: z.boolean().describe('Whether deletion succeeded'),
+			name: z.string().describe('Deleted profile name'),
+		}),
 	},
 
 	async handler(ctx) {
@@ -30,7 +43,7 @@ export const deleteCommand = createSubcommand({
 		const profile = profiles.find((p) => p.name === name);
 
 		if (!profile) {
-			return logger.fatal(`Profile "${name}" not found`);
+			return logger.fatal(`Profile "${name}" not found`, ErrorCode.RESOURCE_NOT_FOUND);
 		}
 
 		// Ask for confirmation unless --confirm flag is passed
@@ -38,7 +51,7 @@ export const deleteCommand = createSubcommand({
 			const confirmed = await tui.confirm(`Delete profile "${name}"?`, false);
 			if (!confirmed) {
 				logger.info('Cancelled');
-				return;
+				return { success: false, name };
 			}
 		}
 
@@ -50,6 +63,8 @@ export const deleteCommand = createSubcommand({
 					'The active profile was deleted. Use "profile use <name>" to select a new default.'
 				);
 			}
+
+			return { success: true, name };
 		} catch (error) {
 			logger.fatal(`Failed to delete profile: ${error}`);
 		}

package/src/cmd/profile/index.ts

@@ -8,5 +8,6 @@ import { deleteCommand } from './delete';
 export const command = createCommand({
 	name: 'profile',
 	description: 'Manage configuration profiles',
+	tags: ['read-only', 'fast'],
 	subcommands: [createProfileCmd, useCommand, listCommand, showCommand, deleteCommand],
 });

package/src/cmd/profile/list.ts

@@ -1,12 +1,16 @@
-import type { SubcommandDefinition } from '../../types';
+import { createSubcommand } from '../../types';
 import { fetchProfiles } from '../../config';
 import { basename, dirname } from 'node:path';
 import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
 
-export const listCommand: SubcommandDefinition = {
+export const listCommand = createSubcommand({
 	name: 'list',
 	description: 'List all available profiles',
+	tags: ['read-only', 'fast'],
+	idempotent: true,
 	aliases: ['ls'],
+	examples: [getCommand('profile list'), getCommand('profile ls')],
 
 	async handler() {
 		const profiles = await fetchProfiles();
@@ -24,4 +28,4 @@ export const listCommand: SubcommandDefinition = {
 			console.log(`${marker} ${name} ${tui.muted(path)}`);
 		}
 	},
-};
+});

package/src/cmd/profile/show.ts

@@ -1,13 +1,23 @@
-import { createSubcommand } from '../../types';
+import { createSubcommand, ConfigSchema } from '../../types';
 import { z } from 'zod';
 import { fetchProfiles, loadConfig } from '../../config';
 import { readFile } from 'node:fs/promises';
 import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
+
+const ProfileShowResponseSchema = ConfigSchema;
 
 export const showCommand = createSubcommand({
 	name: 'show',
 	description: 'Show the configuration of a profile',
+	tags: ['read-only', 'fast'],
 	aliases: ['current'],
+	examples: [
+		getCommand('profile show'),
+		getCommand('profile show production'),
+		getCommand('profile show staging --json'),
+	],
 	schema: {
 		options: z.object({
 			json: z.boolean().optional().describe('Show the JSON config'),
@@ -17,7 +27,9 @@ export const showCommand = createSubcommand({
 				name: z.string().optional().describe('Profile name to show (optional)'),
 			})
 			.describe('Profile show arguments'),
+		response: ProfileShowResponseSchema,
 	},
+	idempotent: true,
 
 	async handler(ctx) {
 		const { logger, args, opts } = ctx;
@@ -35,7 +47,7 @@ export const showCommand = createSubcommand({
 			const profile = profiles.find((p) => p.name === name);
 
 			if (!profile) {
-				return logger.fatal(`Profile "${name}" not found`);
+				return logger.fatal(`Profile "${name}" not found`, ErrorCode.RESOURCE_NOT_FOUND);
 			}
 
 			const profilePath = profile.filename;
@@ -43,14 +55,17 @@ export const showCommand = createSubcommand({
 
 			tui.info(`Profile: ${profilePath}`);
 
+			const content = await loadConfig(current ? undefined : profilePath);
+
 			if (opts?.json) {
-				const content = await loadConfig(current ? undefined : profilePath);
 				console.log(JSON.stringify(content, null, 2));
 			} else {
 				tui.newline();
-				const content = await readFile(profilePath, 'utf-8');
-				console.log(content);
+				const textContent = await readFile(profilePath, 'utf-8');
+				console.log(textContent);
 			}
+
+			return content;
 		} catch (error) {
 			if (error instanceof Error) {
 				logger.fatal(`Failed to show profile: ${error.message}`);

package/src/cmd/profile/use.ts

@@ -2,11 +2,19 @@ import { createSubcommand } from '../../types';
 import { z } from 'zod';
 import { fetchProfiles, saveProfile } from '../../config';
 import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
 
 export const useCommand = createSubcommand({
 	name: 'use',
 	description: 'Switch to a different configuration profile',
+	tags: ['mutating', 'updates-resource', 'fast'],
 	aliases: ['switch'],
+	idempotent: true,
+	examples: [
+		getCommand('profile use production'),
+		getCommand('profile switch staging'),
+		getCommand('profile use'),
+	],
 	schema: {
 		args: z.object({
 			name: z.string().optional().describe('The name of the profile to use'),

package/src/cmd/project/create.ts

@@ -1,15 +1,35 @@
 import { createSubcommand } from '../../types';
 import { z } from 'zod';
 import { runCreateFlow } from './template-flow';
+import { getCommand } from '../../command-prefix';
+
+const ProjectCreateResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	name: z.string().describe('Project name'),
+	path: z.string().describe('Project directory path'),
+	projectId: z.string().optional().describe('Project ID if registered'),
+	template: z.string().describe('Template used'),
+	installed: z.boolean().describe('Whether dependencies were installed'),
+	built: z.boolean().describe('Whether the project was built'),
+});
 
 export const createProjectSubcommand = createSubcommand({
 	name: 'create',
 	description: 'Create a new project',
+	tags: ['mutating', 'creates-resource', 'slow', 'api-intensive', 'requires-auth'],
 	aliases: ['new'],
 	banner: true,
 	toplevel: true,
+	idempotent: false,
 	optional: { auth: true, org: true, region: true },
 	requires: { apiClient: true },
+	examples: [
+		getCommand('project create'),
+		getCommand('project create --name my-ai-agent'),
+		getCommand('project create --name customer-service-bot --dir ~/projects/agent'),
+		getCommand('project create --template basic --no-install'),
+		getCommand('project new --no-register'),
+	],
 	schema: {
 		options: z.object({
 			name: z.string().optional().describe('Project name'),
@@ -40,6 +60,7 @@ export const createProjectSubcommand = createSubcommand({
 				.optional()
 				.describe('Register the project, if authenticated (use --no-register to skip)'),
 		}),
+		response: ProjectCreateResponseSchema,
 	},
 
 	async handler(ctx) {
@@ -61,5 +82,15 @@ export const createProjectSubcommand = createSubcommand({
 			orgId,
 			region,
 		});
+
+		// Return best-effort response (runCreateFlow doesn't return values)
+		return {
+			success: true,
+			name: opts.name || 'project',
+			path: opts.dir || process.cwd(),
+			template: opts.template || 'default',
+			installed: opts.install !== false,
+			built: opts.build !== false,
+		};
 	},
 });

package/src/cmd/project/delete.ts

@@ -3,12 +3,23 @@ import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { projectDelete, projectList } from '@agentuity/server';
 import enquirer from 'enquirer';
+import { getCommand } from '../../command-prefix';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	description: 'Delete a project',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
 	aliases: ['rm', 'del'],
 	requires: { auth: true, apiClient: true },
+	idempotent: false,
+	examples: [
+		getCommand('project delete'),
+		getCommand('project delete proj_abc123def456'),
+		getCommand('project delete proj_abc123def456 --confirm'),
+		getCommand('project rm proj_abc123def456'),
+		getCommand('--explain project delete proj_abc123def456'),
+		getCommand('--dry-run project delete proj_abc123def456'),
+	],
 	schema: {
 		args: z.object({
 			id: z.string().optional().describe('the project id'),
@@ -16,6 +27,11 @@ export const deleteSubcommand = createSubcommand({
 		options: z.object({
 			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
 		}),
+		response: z.object({
+			success: z.boolean().describe('Whether the deletion succeeded'),
+			projectIds: z.array(z.string()).describe('Deleted project IDs'),
+			count: z.number().describe('Number of projects deleted'),
+		}),
 	},
 
 	async handler(ctx) {
@@ -67,7 +83,7 @@ export const deleteSubcommand = createSubcommand({
 
 		if (projectIds.length === 0) {
 			tui.info('No projects selected for deletion');
-			return;
+			return { success: false, projectIds: [], count: 0 };
 		}
 
 		const skipConfirm = opts?.confirm === true;
@@ -90,7 +106,7 @@ export const deleteSubcommand = createSubcommand({
 
 			if (!confirm.confirm) {
 				tui.info('Deletion cancelled');
-				return;
+				return { success: false, projectIds: [], count: 0 };
 			}
 		}
 
@@ -107,5 +123,11 @@ export const deleteSubcommand = createSubcommand({
 		} else {
 			tui.error('Failed to delete projects');
 		}
+
+		return {
+			success: deleted.length > 0,
+			projectIds: deleted,
+			count: deleted.length,
+		};
 	},
 });