@agentuity/cli 0.0.71 → 0.0.73

package/src/cmd/cloud/deploy.ts

@@ -1,23 +1,25 @@
 import { z } from 'zod';
 import { join, resolve } from 'node:path';
 import { createPublicKey } from 'node:crypto';
-import { createReadStream, createWriteStream } from 'node:fs';
+import { createReadStream, createWriteStream, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
-import { saveProjectDir } from '../../config';
+import { saveProjectDir, getDefaultConfigDir } from '../../config';
 import { runSteps, stepSuccess, stepSkipped, stepError, Step, ProgressCallback } from '../../steps';
 import { bundle } from '../build/bundler';
-import { loadBuildMetadata } from '../../config';
+import { loadBuildMetadata, getStreamURL } from '../../config';
 import {
 	projectEnvUpdate,
 	projectDeploymentCreate,
 	projectDeploymentUpdate,
 	projectDeploymentComplete,
+	projectDeploymentStatus,
 	type Deployment,
 	type BuildMetadata,
 	type DeploymentInstructions,
 	type DeploymentComplete,
+	type DeploymentStatusResult,
 } from '@agentuity/server';
 import {
 	findEnvFile,
@@ -30,11 +32,13 @@ import { encryptFIPSKEMDEMStream } from '../../crypto/box';
 import { getCommand } from '../../command-prefix';
 import { checkCustomDomainForDNS } from './domain';
 import { DeployOptionsSchema } from '../../schemas/deploy';
+import { ErrorCode } from '../../errors';
 
 const DeployResponseSchema = z.object({
 	success: z.boolean().describe('Whether deployment succeeded'),
 	deploymentId: z.string().describe('Deployment ID'),
 	projectId: z.string().describe('Project ID'),
+	logs: z.array(z.string()).optional().describe('The deployment startup logs'),
 	urls: z
 		.object({
 			deployment: z.string().describe('Deployment-specific URL'),
@@ -77,12 +81,14 @@ export const deploySubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { project, apiClient, projectDir, config, options, opts } = ctx;
+		const { project, apiClient, projectDir, config, options, opts, logger } = ctx;
 
 		let deployment: Deployment | undefined;
 		let build: BuildMetadata | undefined;
 		let instructions: DeploymentInstructions | undefined;
 		let complete: DeploymentComplete | undefined;
+		let statusResult: DeploymentStatusResult | undefined;
+		const logs: string[] = [];
 
 		try {
 			await saveProjectDir(projectDir);
@@ -237,7 +243,6 @@ export const deploySubcommand = createSubcommand({
 									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;
 								},
@@ -367,9 +372,174 @@ export const deploySubcommand = createSubcommand({
 				].filter(Boolean) as Step[],
 				options.logLevel
 			);
-			tui.success('Your project was deployed!');
 
-			if (complete?.publicUrls && deployment) {
+			if (!deployment) {
+				return {
+					success: false,
+					deploymentId: '',
+					projectId: project.projectId,
+				};
+			}
+
+			const streamId = complete?.streamId;
+
+			// Poll for deployment status with optional log streaming
+			const pollInterval = 500;
+			const maxAttempts = 600;
+			let attempts = 0;
+
+			if (streamId) {
+				// Use progress logger to stream logs while polling
+				const streamsUrl = getStreamURL(project.region, config);
+
+				await tui
+					.progress({
+						message: 'Deploying project...',
+						type: 'logger',
+						maxLines: 2,
+						clearOnSuccess: true,
+						callback: async (log) => {
+							// Start log streaming
+							const logStreamController = new AbortController();
+							const logStreamPromise = (async () => {
+								try {
+									logger.debug('fetching stream: %s/%s', streamsUrl, streamId);
+									const resp = await fetch(`${streamsUrl}/${streamId}`, {
+										signal: logStreamController.signal,
+									});
+									if (!resp.ok || !resp.body) {
+										ctx.logger.trace(
+											`Failed to connect to warmup log stream: ${resp.status}`
+										);
+										return;
+									}
+									const reader = resp.body.getReader();
+									const decoder = new TextDecoder();
+									let buffer = '';
+									while (true) {
+										const { done, value } = await reader.read();
+										if (done) break;
+										buffer += decoder.decode(value, { stream: true });
+										const lines = buffer.split('\n');
+										buffer = lines.pop() || ''; // Keep incomplete line in buffer
+										for (const line of lines) {
+											// Strip ISO 8601 timestamp prefix if present
+											const message = line.replace(
+												/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z\s?/,
+												''
+											);
+											if (message) {
+												logs.push(message);
+												log(message);
+											}
+										}
+									}
+								} catch (err) {
+									if (err instanceof Error && err.name === 'AbortError') {
+										return;
+									}
+									ctx.logger.trace(`Warmup log stream error: ${err}`);
+								}
+							})();
+
+							// Poll for deployment status
+							while (attempts < maxAttempts) {
+								attempts++;
+								try {
+									statusResult = await projectDeploymentStatus(
+										apiClient,
+										deployment?.id ?? ''
+									);
+
+									logger.trace('status result: %s', statusResult);
+
+									if (statusResult.state === 'completed') {
+										logStreamController.abort();
+										break;
+									}
+
+									if (statusResult.state === 'failed') {
+										throw new Error('Deployment failed');
+									}
+
+									await Bun.sleep(pollInterval);
+								} catch (err) {
+									logStreamController.abort();
+									throw err;
+								}
+							}
+
+							// Wait for log stream to finish
+							await logStreamPromise;
+
+							if (attempts >= maxAttempts) {
+								throw new Error('Deployment timed out');
+							}
+						},
+					})
+					.then(() => {
+						tui.success('Your project was deployed!');
+					})
+					.catch((ex) => {
+						const exwithmessage = ex as { message: string };
+						const msg =
+							exwithmessage.message === 'Deployment failed' ? '' : exwithmessage.toString();
+						tui.error(`Your deployment failed to start${msg ? `: ${msg}` : ''}`);
+						if (logs.length) {
+							const logsDir = join(getDefaultConfigDir(), 'logs');
+							if (!existsSync(logsDir)) {
+								mkdirSync(logsDir, { recursive: true });
+							}
+							const errorFile = join(logsDir, `${deployment?.id ?? Date.now()}.txt`);
+							writeFileSync(errorFile, logs.join('\n'));
+							const count = Math.min(logs.length, 10);
+							const last = logs.length - count;
+							tui.newline();
+							tui.warning(`The last ${count} lines of the log:`);
+							let offset = last + 1; // we want to show the offset from inside the log starting at 1
+							const max = String(logs.length).length;
+							for (const _log of logs.slice(last)) {
+								console.log(tui.muted(`${offset.toFixed().padEnd(max)} | ${_log}`));
+								offset++;
+							}
+							tui.newline();
+							tui.fatal(`The logs were written to ${errorFile}`, ErrorCode.BUILD_FAILED);
+						}
+						tui.fatal('Deployment failed', ErrorCode.BUILD_FAILED);
+					});
+			} else {
+				// No stream ID - poll without log streaming
+				await tui.spinner({
+					message: 'Deploying project...',
+					type: 'simple',
+					clearOnSuccess: true,
+					callback: async () => {
+						while (attempts < maxAttempts) {
+							attempts++;
+							statusResult = await projectDeploymentStatus(apiClient, deployment?.id ?? '');
+
+							if (statusResult.state === 'completed') {
+								break;
+							}
+
+							if (statusResult.state === 'failed') {
+								throw new Error('Deployment failed');
+							}
+
+							await Bun.sleep(pollInterval);
+						}
+
+						if (attempts >= maxAttempts) {
+							throw new Error('Deployment timed out');
+						}
+					},
+				});
+
+				tui.success('Your project was deployed!');
+			}
+
+			// Show deployment URLs
+			if (complete?.publicUrls) {
 				tui.arrow(tui.bold(tui.padRight('Deployment ID:', 17)) + tui.link(deployment.id));
 				if (complete.publicUrls.custom?.length) {
 					for (const url of complete.publicUrls.custom) {
@@ -386,25 +556,18 @@ 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: '',
+				success: true,
+				deploymentId: deployment.id,
 				projectId: project.projectId,
+				logs,
+				urls: complete?.publicUrls
+					? {
+							deployment: complete.publicUrls.deployment,
+							latest: complete.publicUrls.latest,
+							custom: complete.publicUrls.custom,
+						}
+					: undefined,
 			};
 		} catch (ex) {
 			tui.fatal(`unexpected error trying to deploy project. ${ex}`);

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

@@ -15,6 +15,10 @@ const DeploymentShowResponseSchema = z.object({
 	tags: z.array(z.string()).describe('Deployment tags'),
 	customDomains: z.array(z.string()).optional().describe('Custom domains'),
 	cloudRegion: z.string().optional().describe('Cloud region'),
+	resourceDb: z.string().nullable().optional().describe('the database name'),
+	resourceStorage: z.string().nullable().optional().describe('the storage name'),
+	deploymentLogsURL: z.string().nullable().optional().describe('the url to the deployment logs'),
+	buildLogsURL: z.string().nullable().optional().describe('the url to the build logs'),
 	metadata: z
 		.object({
 			git: z
@@ -87,27 +91,51 @@ export const showSubcommand = createSubcommand({
 
 			// Skip TUI output in JSON mode
 			if (!options.json) {
-				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());
+				const maxWidth = 18;
+				console.log(tui.bold('ID:'.padEnd(maxWidth)) + deployment.id);
+				console.log(tui.bold('Project:'.padEnd(maxWidth)) + projectId);
+				console.log(tui.bold('State:'.padEnd(maxWidth)) + (deployment.state || 'unknown'));
+				console.log(tui.bold('Active:'.padEnd(maxWidth)) + (deployment.active ? 'Yes' : 'No'));
+				console.log(
+					tui.bold('Created:'.padEnd(maxWidth)) +
+						new Date(deployment.createdAt).toLocaleString()
+				);
 				if (deployment.updatedAt) {
 					console.log(
-						tui.bold('Updated:  ') + new Date(deployment.updatedAt).toLocaleString()
+						tui.bold('Updated:'.padEnd(maxWidth)) +
+							new Date(deployment.updatedAt).toLocaleString()
 					);
 				}
 				if (deployment.message) {
-					console.log(tui.bold('Message:  ') + deployment.message);
+					console.log(tui.bold('Message:'.padEnd(maxWidth)) + deployment.message);
 				}
 				if (deployment.tags.length > 0) {
-					console.log(tui.bold('Tags:     ') + deployment.tags.join(', '));
+					console.log(tui.bold('Tags:'.padEnd(maxWidth)) + deployment.tags.join(', '));
 				}
 				if (deployment.customDomains && deployment.customDomains.length > 0) {
-					console.log(tui.bold('Domains:  ') + deployment.customDomains.join(', '));
+					console.log(
+						tui.bold('Domains:'.padEnd(maxWidth)) + deployment.customDomains.join(', ')
+					);
 				}
 				if (deployment.cloudRegion) {
-					console.log(tui.bold('Region:   ') + deployment.cloudRegion);
+					console.log(tui.bold('Region:'.padEnd(maxWidth)) + deployment.cloudRegion);
+				}
+				if (deployment.resourceDb) {
+					console.log(tui.bold('Database:'.padEnd(maxWidth)) + deployment.resourceDb);
+				}
+				if (deployment.resourceStorage) {
+					console.log(tui.bold('Storage:'.padEnd(maxWidth)) + deployment.resourceStorage);
+				}
+				if (deployment.deploymentLogsURL) {
+					console.log(
+						tui.bold('Deployment Logs:'.padEnd(maxWidth)) +
+							tui.link(deployment.deploymentLogsURL)
+					);
+				}
+				if (deployment.buildLogsURL) {
+					console.log(
+						tui.bold('Build Logs:'.padEnd(maxWidth)) + tui.link(deployment.buildLogsURL)
+					);
 				}
 
 				// Git metadata
@@ -153,6 +181,10 @@ export const showSubcommand = createSubcommand({
 				customDomains: deployment.customDomains ?? undefined,
 				cloudRegion: deployment.cloudRegion ?? undefined,
 				metadata: deployment.metadata ?? undefined,
+				resourceDb: deployment.resourceDb ?? undefined,
+				resourceStorage: deployment.resourceStorage ?? undefined,
+				deploymentLogsURL: deployment.deploymentLogsURL ?? undefined,
+				buildLogsURL: deployment.buildLogsURL ?? undefined,
 			};
 		} catch (ex) {
 			tui.fatal(`Failed to show deployment: ${ex}`);

package/src/cmd/cloud/session/get.ts

@@ -125,8 +125,8 @@ export const getSubcommand = createSubcommand({
 		response: SessionGetResponseSchema,
 	},
 	async handler(ctx) {
-		const { config, logger, auth, args, options, region } = ctx;
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const { logger, auth, args, options, region } = ctx;
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		try {
 			const enriched = await sessionGet(catalystClient, { id: args.session_id });

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

@@ -89,8 +89,8 @@ export const listSubcommand = createSubcommand({
 		response: SessionListResponseSchema,
 	},
 	async handler(ctx) {
-		const { config, logger, auth, project, opts, options, region } = ctx;
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const { logger, auth, project, opts, options, region } = ctx;
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const projectId = opts.projectId || project?.projectId;
 

package/src/cmd/cloud/storage/create.ts

@@ -35,7 +35,7 @@ export const createSubcommand = defineSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, orgId, region, config, auth, options } = ctx;
+		const { logger, orgId, region, auth, options } = ctx;
 
 		// Handle dry-run mode
 		if (isDryRunMode(options)) {
@@ -51,7 +51,7 @@ export const createSubcommand = defineSubcommand({
 			};
 		}
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const created = await tui.spinner({
 			message: `Creating storage in ${region}`,

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

@@ -49,9 +49,9 @@ export const deleteSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, config, orgId, region, auth, options } = ctx;
+		const { logger, args, opts, orgId, region, auth, options } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const resources = await tui.spinner({
 			message: `Fetching storage for ${orgId} in ${region}`,

package/src/cmd/cloud/storage/download.ts

@@ -51,9 +51,9 @@ export const downloadSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+		const { logger, args, opts, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		// Fetch bucket credentials
 		const resources = await tui.spinner({

package/src/cmd/cloud/storage/get.ts

@@ -51,9 +51,9 @@ export const getSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+		const { logger, args, opts, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const resources = await tui.spinner({
 			message: `Fetching storage bucket ${args.name}`,

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

@@ -74,9 +74,9 @@ export const listSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+		const { logger, args, opts, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const resources = await tui.spinner({
 			message: `Fetching storage for ${orgId} in ${region}`,

package/src/cmd/cloud/storage/upload.ts

@@ -49,9 +49,9 @@ export const uploadSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+		const { logger, args, opts, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		// Fetch bucket credentials
 		const resources = await tui.spinner({

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

@@ -24,8 +24,8 @@ export const deleteSubcommand = createSubcommand({
 		}),
 	},
 	async handler(ctx) {
-		const { config, logger, auth, args, region } = ctx;
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const { logger, auth, args, region } = ctx;
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		try {
 			await threadDelete(catalystClient, { id: args.thread_id });

package/src/cmd/cloud/thread/get.ts

@@ -37,8 +37,8 @@ export const getSubcommand = createSubcommand({
 		response: ThreadGetResponseSchema,
 	},
 	async handler(ctx) {
-		const { config, logger, auth, args, options, region } = ctx;
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const { logger, auth, args, options, region } = ctx;
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		try {
 			const thread = await threadGet(catalystClient, { id: args.thread_id });

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

@@ -62,8 +62,8 @@ export const listSubcommand = createSubcommand({
 		response: ThreadListResponseSchema,
 	},
 	async handler(ctx) {
-		const { config, logger, auth, project, opts, options, region } = ctx;
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const { logger, auth, project, opts, options, region } = ctx;
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const projectId = opts.projectId || project?.projectId;
 		const orgId = opts.orgId;

package/src/cmd/dev/agents.ts

@@ -63,14 +63,12 @@ export const agentsSubcommand = createSubcommand({
 		const queryParams = deploymentId ? `?deploymentId=${deploymentId}` : '';
 
 		const response = options.json
-			? await apiClient.request(
-					'GET',
+			? await apiClient.get(
 					`/cli/agent/${projectId}${queryParams}`,
 					AgentsResponseSchema
 				)
 			: await tui.spinner('Fetching agents', async () => {
-					return apiClient.request(
-						'GET',
+					return apiClient.get(
 						`/cli/agent/${projectId}${queryParams}`,
 						AgentsResponseSchema
 					);

package/src/cmd/dev/sync.ts

@@ -253,11 +253,10 @@ class DevmodeSyncService implements IDevmodeSyncService {
 			JSON.stringify(payload, null, 2)
 		);
 
-		await this.apiClient.request(
-			'POST',
+		await this.apiClient.post(
 			'/cli/devmode/agent',
-			z.object({ success: z.boolean() }),
-			payload
+			payload,
+			z.object({ success: z.boolean() })
 		);
 	}
 
@@ -280,11 +279,10 @@ class DevmodeSyncService implements IDevmodeSyncService {
 			JSON.stringify(payload, null, 2)
 		);
 
-		await this.apiClient.request(
-			'POST',
+		await this.apiClient.post(
 			'/cli/devmode/eval',
-			z.object({ success: z.boolean() }),
-			payload
+			payload,
+			z.object({ success: z.boolean() })
 		);
 	}
 }

package/src/cmd/project/show.ts

@@ -6,8 +6,10 @@ import { getCommand } from '../../command-prefix';
 
 const ProjectShowResponseSchema = z.object({
 	id: z.string().describe('Project ID'),
+	name: z.string().describe('Project name'),
+	description: z.string().nullable().optional().describe('Project description'),
+	tags: z.array(z.string()).nullable().optional().describe('Project tags'),
 	orgId: z.string().describe('Organization ID'),
-	name: z.string().optional().describe('Project name'),
 	secrets: z.record(z.string(), z.string()).optional().describe('Project secrets (masked)'),
 	env: z.record(z.string(), z.string()).optional().describe('Environment variables'),
 });
@@ -45,16 +47,16 @@ export const showSubcommand = createSubcommand({
 			tui.fatal('Project not found');
 		}
 
-		if (options.json) {
-			console.log(JSON.stringify(project, null, 2));
-		} else {
-			tui.table([project], ['id', 'orgId']);
+		if (!options.json) {
+			tui.table([project], ['id', 'name', 'description', 'tags', 'orgId']);
 		}
 
 		return {
 			id: project.id,
+			name: project.name,
+			description: project.description,
+			tags: project.tags,
 			orgId: project.orgId,
-			name: undefined,
 			secrets: project.secrets,
 			env: project.env,
 		};

package/src/cmd/project/template-flow.ts

@@ -177,7 +177,13 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 	if (initialTemplate) {
 		const found = templates.find((t) => t.id === initialTemplate);
 		if (!found) {
-			logger.fatal(`Template "${initialTemplate}" not found`, ErrorCode.RESOURCE_NOT_FOUND);
+			const availableTemplates = templates
+				.map((t) => `  - ${t.id.padEnd(20)} ${t.description}`)
+				.join('\n');
+			logger.fatal(
+				`Template "${initialTemplate}" not found\n\nAvailable templates:\n${availableTemplates}`,
+				ErrorCode.RESOURCE_NOT_FOUND
+			);
 			return;
 		}
 		selectedTemplate = found;
@@ -232,7 +238,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 
 	const resourceConfig: ResourcesTypes = Resources.parse({});
 
-	if (auth && apiClient && catalystClient && orgId && region) {
+	if (auth && apiClient && catalystClient && orgId && region && !skipPrompts) {
 		// Fetch resources for selected org and region using Catalyst API
 		const resources = await tui.spinner({
 			message: 'Fetching resources',
@@ -316,12 +322,25 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 
 		const cloudRegion = region ?? process.env.AGENTUITY_REGION ?? 'usc';
 
+		const pkgJsonPath = resolve(dest, 'package.json');
+		let pkgJson: { description?: string; keywords?: string[] } = {};
+		if (existsSync(pkgJsonPath)) {
+			pkgJson = await Bun.file(pkgJsonPath).json();
+		}
+
+		const keywords = Array.isArray(pkgJson.keywords) ? pkgJson.keywords : [];
+		const tags = keywords.filter(
+			(tag) => tag.toLowerCase() !== 'agentuity' && !tag.toLowerCase().startsWith('agentuity')
+		);
+
 		await tui.spinner({
 			message: 'Registering your project',
 			clearOnSuccess: true,
 			callback: async () => {
 				const project = await projectCreate(apiClient, {
 					name: projectName,
+					description: pkgJson.description,
+					tags: tags.length > 0 ? tags : undefined,
 					orgId,
 					cloudRegion,
 				});