@agentuity/cli 0.0.47 → 0.0.49

package/src/cmd/objectstore/get.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import * as tui from '../../tui';
+import { tryParseJSON } from '../../json';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../command-prefix';
+
+const ObjectGetResponseSchema = z.object({
+	exists: z.boolean().describe('Whether the object exists'),
+	data: z.any().optional().describe('Object data (binary)'),
+	contentType: z.string().optional().describe('Content type'),
+});
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get an object from the object storage',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	requires: { auth: true, project: true },
+	examples: [
+		`${getCommand('objectstore get uploads images/logo.png')} - Download logo image`,
+		`${getCommand('objectstore get assets data/export.json')} - Get JSON export`,
+		`${getCommand('objectstore get backups db-2024.sql')} - Get database backup`,
+	],
+	schema: {
+		args: z.object({
+			bucket: z.string().min(1).describe('the bucket name'),
+			key: z.string().min(1).describe('the key name'),
+		}),
+		response: ObjectGetResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args } = ctx;
+		const storage = await createStorageAdapter(ctx);
+		const started = Date.now();
+		const res = await storage.get(args.bucket, args.key);
+		if (res.exists) {
+			if (res.data) {
+				if (res.contentType?.includes('json')) {
+					const val = tryParseJSON(new TextDecoder().decode(res.data));
+					tui.json(val);
+				} else if (res.contentType?.includes('text')) {
+					console.log(new TextDecoder().decode(res.data));
+				} else {
+					tui.info(`Read ${res.data.byteLength} bytes (${res.contentType})`);
+				}
+				tui.success(`retrieved in ${(Date.now() - started).toFixed(1)}ms (${res.contentType})`);
+			} else {
+				tui.warning(`${args.key} returned empty data for bucket ${args.bucket}`);
+			}
+		} else {
+			tui.warning(`${args.key} does not exist in bucket ${args.bucket}`);
+		}
+
+		return {
+			exists: res.exists,
+			data: res.data,
+			contentType: res.exists ? res.contentType : undefined,
+		};
+	},
+});
+
+export default getSubcommand;

package/src/cmd/objectstore/index.ts

@@ -0,0 +1,27 @@
+import { createCommand } from '../../types';
+import { deleteSubcommand } from './delete';
+import { deleteBucketSubcommand } from './delete-bucket';
+import { getSubcommand } from './get';
+import { listBucketsSubcommand } from './list-buckets';
+import { listKeysSubcommand } from './list-keys';
+import { putSubcommand } from './put';
+import { replSubcommand } from './repl';
+import { urlSubcommand } from './url';
+
+export const command = createCommand({
+	name: 'objectstore',
+	aliases: ['object', 'obj'],
+	description: 'Manage object storage for your projects',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	subcommands: [
+		replSubcommand,
+		getSubcommand,
+		putSubcommand,
+		deleteSubcommand,
+		urlSubcommand,
+		listBucketsSubcommand,
+		listKeysSubcommand,
+		deleteBucketSubcommand,
+	],
+	requires: { auth: true, project: true },
+});

package/src/cmd/objectstore/list-buckets.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import * as tui from '../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../command-prefix';
+
+const BucketListResponseSchema = z.array(
+	z.object({
+		name: z.string().describe('Bucket name'),
+		object_count: z.number().describe('Number of objects in bucket'),
+		total_bytes: z.number().describe('Total size in bytes'),
+	})
+);
+
+export const listBucketsSubcommand = createCommand({
+	name: 'list-buckets',
+	description: 'List all object storage buckets',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, project: true },
+	schema: {
+		response: BucketListResponseSchema,
+	},
+	idempotent: true,
+	examples: [`${getCommand('objectstore list-buckets')} - List all buckets with stats`],
+
+	async handler(ctx) {
+		const storage = await createStorageAdapter(ctx);
+		const buckets = await storage.listBuckets();
+
+		if (buckets.length === 0) {
+			tui.info('No buckets found');
+			return [];
+		}
+
+		tui.info(`Found ${buckets.length} bucket(s):`);
+		for (const bucket of buckets) {
+			const sizeMB = (bucket.total_bytes / (1024 * 1024)).toFixed(2);
+			tui.info(`  ${tui.bold(bucket.name)}: ${bucket.object_count} objects, ${sizeMB} MB`);
+		}
+
+		return buckets;
+	},
+});
+
+export default listBucketsSubcommand;

package/src/cmd/objectstore/list-keys.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import * as tui from '../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../command-prefix';
+
+export const listKeysSubcommand = createCommand({
+	name: 'list-keys',
+	aliases: ['ls', 'list'],
+	description: 'List all keys in an object storage bucket',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	requires: { auth: true, project: true },
+	idempotent: true,
+	examples: [
+		`${getCommand('objectstore list-keys uploads')} - List all uploaded files`,
+		`${getCommand('objectstore ls assets')} - List assets (using alias)`,
+		`${getCommand('objectstore list backups')} - List all backups`,
+	],
+	schema: {
+		args: z.object({
+			bucket: z.string().min(1),
+		}),
+		response: z.object({
+			bucket: z.string().describe('Bucket name'),
+			objects: z
+				.array(
+					z.object({
+						key: z.string().describe('Object key'),
+						size: z.number().describe('Object size in bytes'),
+						updated_at: z.string().describe('Last update timestamp'),
+					})
+				)
+				.describe('List of objects in the bucket'),
+			count: z.number().describe('Number of objects found'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args } = ctx;
+		const objectStore = await createStorageAdapter(ctx);
+
+		const objects = await objectStore.listKeys(args.bucket);
+
+		if (objects.length === 0) {
+			tui.info(`No objects found in bucket ${tui.bold(args.bucket)}`);
+			return { bucket: args.bucket, objects: [], count: 0 };
+		}
+
+		tui.info(`Found ${objects.length} object(s) in ${tui.bold(args.bucket)}:`);
+		for (const obj of objects) {
+			const sizeMB = (obj.size / (1024 * 1024)).toFixed(2);
+			const date = new Date(obj.updated_at).toLocaleString();
+			tui.info(`  ${tui.bold(obj.key)}: ${sizeMB} MB, updated ${date}`);
+		}
+
+		return { bucket: args.bucket, objects, count: objects.length };
+	},
+});
+
+export default listKeysSubcommand;

package/src/cmd/objectstore/put.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import * as tui from '../../tui';
+import { isPossiblyJSON } from '../../json';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../command-prefix';
+
+const ObjectStorePutResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	bucket: z.string().describe('Bucket name'),
+	key: z.string().describe('Object key'),
+	size: z.number().describe('Size in bytes'),
+	contentType: z.string().describe('Content type'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+export const putSubcommand = createCommand({
+	name: 'put',
+	description: 'Put an object into the object storage',
+	tags: ['mutating', 'creates-resource', 'slow', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, project: true },
+	examples: [
+		`${getCommand('objectstore put uploads images/logo.png @./logo.png')} - Upload logo from file`,
+		`${getCommand('objectstore put assets data/config.json \'{"api":"https://api.example.com"}\'')} - Store JSON config`,
+		`${getCommand('objectstore put backups db-2024.sql @~/Downloads/backup.sql --content-type application/sql')} - Upload SQL backup`,
+	],
+	schema: {
+		args: z.object({
+			bucket: z.string().min(1).max(64).describe('the bucket name'),
+			key: z.string().min(1).max(64).describe('the key name'),
+			value: z.string().min(1).describe('the value'),
+			contentType: z.string().optional().describe('an optional content type'),
+		}),
+		response: ObjectStorePutResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+		const contentType =
+			args.contentType ?? (isPossiblyJSON(args.value) ? 'application/json' : 'text/plain');
+		const data = new TextEncoder().encode(args.value);
+		await storage.put(args.bucket, args.key, data, {
+			contentType,
+		});
+		const durationMs = Date.now() - started;
+		tui.success(`saved in ${durationMs.toFixed(1)}ms (${contentType})`);
+
+		return {
+			success: true,
+			bucket: args.bucket,
+			key: args.key,
+			size: data.length,
+			contentType,
+			durationMs,
+		};
+	},
+});
+
+export default putSubcommand;

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

@@ -1,21 +1,33 @@
-import { createSubcommand } from '../../types';
+import { join } from 'node:path';
+import { writeFile, readdir } from 'node:fs/promises';
+import { Config, createSubcommand } from '../../types';
 import { z } from 'zod';
 import {
 	fetchProfiles,
 	getDefaultConfigDir,
 	ensureConfigDir,
 	generateYAMLTemplate,
+	loadConfig,
+	saveConfig,
+	saveProfile,
 } from '../../config';
-import { join } from 'node:path';
-import { writeFile } from 'node:fs/promises';
 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({
@@ -26,17 +38,28 @@ export const createCommand = createSubcommand({
 					.describe('The name of the profile to create'),
 			})
 			.describe('Profile creation arguments'),
+		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) {
-		const { logger, args } = ctx;
+		const { logger, args, opts } = ctx;
 		const { name } = args;
 
 		const profiles = await fetchProfiles();
 		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();
@@ -47,11 +70,43 @@ export const createCommand = createSubcommand({
 
 		try {
 			await writeFile(filename, template, { flag: 'wx', mode: 0o600 });
+			if (name === 'local') {
+				// if we're creating a local profile, go ahead and fill it out for the dev to make it easier to get started
+				const localConfig = (await loadConfig(filename)) as Config;
+				localConfig.overrides = {
+					api_url: 'https://api.agentuity.io',
+					app_url: 'https://app.agentuity.io',
+					transport_url: 'https://catalyst.agentuity.io',
+					stream_url: 'https://streams.agentuity.io',
+					kv_url: 'https://catalyst.agentuity.io',
+					object_url: 'https://catalyst.agentuity.io',
+					vector_url: 'https://catalyst.agentuity.io',
+					catalyst_url: 'https://catalyst.agentuity.io',
+					ion_url: 'https://ion.agentuity.io',
+					gravity_url: 'grpc://gravity.agentuity.io:8443',
+				};
+				await saveConfig(localConfig, filename);
+			}
+
+			const files = await readdir(configDir);
+			if (opts?.switch || files.length === 1) {
+				await saveProfile(filename);
+			}
+
 			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
+			);
 		}
 	},
 });