@agentuity/cli 0.0.43 → 0.0.45

package/src/cmd/project/list.ts

@@ -2,13 +2,12 @@ import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { projectList } from '@agentuity/server';
-import { getAPIBaseURL, APIClient } from '../../api';
 
 export const listSubcommand = createSubcommand({
 	name: 'list',
 	description: 'List all projects',
 	aliases: ['ls'],
-	requiresAuth: true,
+	requires: { auth: true, apiClient: true },
 	schema: {
 		options: z.object({
 			format: z
@@ -19,13 +18,14 @@ export const listSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { config, opts } = ctx;
+		const { apiClient, opts } = ctx;
 
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
-
-		const projects = await tui.spinner('Fetching projects', () => {
-			return projectList(client!);
+		const projects = await tui.spinner({
+			message: 'Fetching projects',
+			clearOnSuccess: true,
+			callback: () => {
+				return projectList(apiClient);
+			},
 		});
 
 		// TODO: might want to sort by the last org_id we used

package/src/cmd/project/show.ts

@@ -2,13 +2,12 @@ import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { projectGet } from '@agentuity/server';
-import { getAPIBaseURL, APIClient } from '../../api';
 
 export const showSubcommand = createSubcommand({
 	name: 'show',
 	aliases: ['get'],
 	description: 'Show project detail',
-	requiresAuth: true,
+	requires: { auth: true, apiClient: true },
 	schema: {
 		args: z.object({
 			id: z.string().describe('the project id'),
@@ -22,13 +21,10 @@ export const showSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { opts, args, config } = ctx;
-
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
+		const { opts, args, apiClient } = ctx;
 
 		const project = await tui.spinner('Fetching project', () => {
-			return projectGet(client!, { id: args.id, mask: true });
+			return projectGet(apiClient, { id: args.id, mask: true });
 		});
 
 		if (!project) {

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

@@ -1,4 +1,5 @@
 import { basename, resolve } from 'node:path';
+import { z } from 'zod';
 import { existsSync, readdirSync, rmSync, statSync } from 'node:fs';
 import { cwd } from 'node:process';
 import { homedir } from 'node:os';
@@ -6,19 +7,21 @@ import enquirer from 'enquirer';
 import {
 	projectCreate,
 	projectExists,
-	listOrganizations,
+	listResources,
 	projectEnvUpdate,
-	type OrganizationList,
+	getServiceUrls,
+	APIClient as ServerAPIClient,
+	Resources,
+	createResources,
 } from '@agentuity/server';
 import type { Logger } from '@agentuity/core';
 import * as tui from '../../tui';
 import { playSound } from '../../sound';
 import { fetchTemplates, type TemplateInfo } from './templates';
 import { downloadTemplate, setupProject } from './download';
-import { showBanner } from '../../banner';
 import type { AuthData, Config } from '../../types';
-import { getAPIBaseURL, APIClient } from '../../api';
-import { createProjectConfig, saveOrgId } from '../../config';
+import type { APIClient } from '../../api';
+import { createProjectConfig } from '../../config';
 import {
 	findEnvFile,
 	readEnvFile,
@@ -26,6 +29,8 @@ import {
 	splitEnvAndSecrets,
 } from '../../env-util';
 
+type ResourcesTypes = z.infer<typeof Resources>;
+
 interface CreateFlowOptions {
 	projectName?: string;
 	dir?: string;
@@ -38,6 +43,9 @@ interface CreateFlowOptions {
 	logger: Logger;
 	auth?: AuthData;
 	config?: Config;
+	orgId?: string;
+	region?: string;
+	apiClient?: APIClient;
 }
 
 export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
@@ -51,47 +59,39 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		logger,
 		auth,
 		config,
+		orgId: selectedOrgId,
+		region,
+		apiClient,
 	} = options;
 
-	showBanner();
-
-	// Step 1: Fetch available templates
+	// Fetch available templates
 	if (templateDir) {
 		tui.info(`📋 Loading templates from local directory: ${templateDir}...\n`);
 	}
 
-	const templates = await tui.spinner('Fetching templates', async () => {
-		return fetchTemplates(templateDir, templateBranch);
+	const templates = await tui.spinner({
+		message: 'Fetching templates',
+		clearOnSuccess: true,
+		callback: async () => {
+			return fetchTemplates(templateDir, templateBranch);
+		},
 	});
 
 	if (templates.length === 0) {
 		logger.fatal('No templates available');
 	}
 
-	// Step 2: Get project name
+	// Get project name
 	let projectName = initialProjectName;
 
-	let orgs: OrganizationList | undefined;
-	let client: APIClient | undefined;
-	let orgId: string | undefined;
+	// Organization is now automatically selected by the CLI framework via optional: { org: true }
+	const orgId = selectedOrgId;
+	let catalystClient: ServerAPIClient | undefined;
 
 	if (auth) {
-		const apiUrl = getAPIBaseURL(config);
-		client = new APIClient(apiUrl, config);
-		orgs = await tui.spinner('Fetching organizations', async () => {
-			const resp = await listOrganizations(client!);
-			if (resp.data) {
-				return resp.data;
-			}
-		});
-		if (!orgs) {
-			tui.fatal('no organizations could be found for your login');
-		}
-		orgId = await tui.selectOrganization(orgs, config?.preferences?.orgId);
-
-		if (orgId && orgId !== config?.preferences?.orgId) {
-			await saveOrgId(orgId);
-		}
+		const serviceUrls = getServiceUrls();
+		const catalystUrl = config?.overrides?.catalyst_url ?? serviceUrls.catalyst;
+		catalystClient = new ServerAPIClient(catalystUrl, logger, auth.apiKey);
 	}
 
 	if (!projectName && !skipPrompts) {
@@ -104,8 +104,11 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 				if (!value || value.trim().length === 0) {
 					return 'Project name is required';
 				}
-				if (client) {
-					const exists = await projectExists(client, { name: value, organization_id: orgId! });
+				if (apiClient && auth && orgId) {
+					const exists = await projectExists(apiClient, {
+						name: value,
+						organization_id: orgId,
+					});
 					if (exists) {
 						return `Project with name '${value}' already exists in this organization`;
 					}
@@ -117,13 +120,13 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 	}
 	projectName = projectName || 'My First Agent';
 
-	// Step 3: Generate disk-friendly directory name
+	// Generate disk-friendly directory name
 	const dirName = projectName === '.' ? '.' : sanitizeDirectoryName(projectName);
 
-	// Step 4: Determine destination directory
+	// Determine destination directory
 	// Expand ~ to home directory
 	let expandedTargetDir = targetDir;
-	if (expandedTargetDir && expandedTargetDir.startsWith('~')) {
+	if (expandedTargetDir?.startsWith('~')) {
 		expandedTargetDir = expandedTargetDir.replace(/^~/, homedir());
 	}
 	const baseDir = expandedTargetDir ? resolve(expandedTargetDir) : process.cwd();
@@ -155,7 +158,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 				return;
 			}
 			rmSync(dest, { recursive: true, force: true });
-			tui.success(`Deleted ${dest}\n`);
+			tui.success(`Deleted ${dest}`);
 		} else {
 			logger.fatal(`Directory ${dest} already exists and is not empty.`, true);
 		}
@@ -192,7 +195,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 
 	tui.info(`✨ Using template: ${tui.bold(selectedTemplate.name)}`);
 
-	// Step 6: Download template
+	// Download template
 	await downloadTemplate({
 		dest,
 		template: selectedTemplate,
@@ -201,7 +204,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		logger,
 	});
 
-	// Step 7: Setup project (replace placeholders, install deps, build)
+	// Setup project (replace placeholders, install deps, build)
 	await setupProject({
 		dest,
 		projectName: projectName === '.' ? basename(dest) : projectName,
@@ -211,58 +214,153 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		logger,
 	});
 
-	if (auth && client && orgId) {
+	const resourceConfig: ResourcesTypes = Resources.parse({});
+
+	if (auth && apiClient && catalystClient && orgId && region) {
+		// Fetch resources for selected org and region using Catalyst API
+		const resources = await tui.spinner({
+			message: 'Fetching resources',
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		logger.debug(`Resources for org ${orgId} in region ${region}:`, resources);
+
+		const choices = await enquirer.prompt<{
+			db_action: string;
+			s3_action: string;
+		}>([
+			{
+				type: 'select',
+				name: 'db_action',
+				message: 'Create SQL Database?',
+				choices: [
+					{ name: 'Create New', message: 'Create a new (free)' },
+					{ name: 'Skip', message: 'Skip or Setup later' },
+					...resources.db.map((db) => ({
+						name: db.name,
+						message: `Use database: ${db.name}`,
+					})),
+				],
+			},
+			{
+				type: 'select',
+				name: 's3_action',
+				message: 'Create Storage Bucket?',
+				choices: [
+					{ name: 'Create New', message: 'Create a new (free)' },
+					{ name: 'Skip', message: 'Skip or Setup later' },
+					...resources.s3.map((db) => ({
+						name: db.bucket_name,
+						message: `Use bucket: ${db.bucket_name}`,
+					})),
+				],
+			},
+		]);
+		switch (choices.s3_action) {
+			case 'Create New': {
+				const created = await tui.spinner({
+					message: 'Provisioning New Bucket',
+					clearOnSuccess: true,
+					callback: async () => {
+						return createResources(catalystClient, orgId, region!, [{ type: 's3' }]);
+					},
+				});
+				resourceConfig.storage = created[0].name;
+				break;
+			}
+			case 'Skip': {
+				break;
+			}
+			default: {
+				resourceConfig.storage = choices.s3_action;
+				break;
+			}
+		}
+		switch (choices.db_action) {
+			case 'Create New': {
+				const created = await tui.spinner({
+					message: 'Provisioning New SQL Database',
+					clearOnSuccess: true,
+					callback: async () => {
+						return createResources(catalystClient, orgId, region!, [{ type: 'db' }]);
+					},
+				});
+				resourceConfig.db = created[0].name;
+				break;
+			}
+			case 'Skip': {
+				break;
+			}
+			default: {
+				resourceConfig.db = choices.db_action;
+				break;
+			}
+		}
+	}
+
+	if (auth && apiClient && orgId) {
 		let projectId: string | undefined;
 
-		await tui.spinner('Registering your project', async () => {
-			const res = await projectCreate(client, {
-				name: projectName,
-				organization_id: orgId,
-				provider: 'bunjs',
-			});
-			if (res.success && res.data) {
-				projectId = res.data.id;
+		await tui.spinner({
+			message: 'Registering your project',
+			clearOnSuccess: true,
+			callback: async () => {
+				const project = await projectCreate(apiClient, {
+					name: projectName,
+					organization_id: orgId,
+					provider: 'bunjs',
+				});
+				projectId = project.id;
 				return createProjectConfig(dest, {
-					projectId: res.data.id,
+					projectId: project.id,
 					orgId,
-					apiKey: res.data.api_key,
+					apiKey: project.api_key,
+					deployment: {
+						resources: resourceConfig,
+					},
 				});
-			}
-			tui.fatal(res.message ?? 'failed to register project');
+			},
 		});
 
 		// After registration, push any existing env/secrets from .env.production
 		if (projectId) {
-			await tui.spinner('Syncing environment variables', async () => {
-				try {
-					const envFilePath = await findEnvFile(dest);
-					const localEnv = await readEnvFile(envFilePath);
-					const filteredEnv = filterAgentuitySdkKeys(localEnv);
+			await tui.spinner({
+				message: 'Syncing environment variables',
+				clearOnSuccess: true,
+				callback: async () => {
+					try {
+						const envFilePath = await findEnvFile(dest);
+						const localEnv = await readEnvFile(envFilePath);
+						const filteredEnv = filterAgentuitySdkKeys(localEnv);
 
-					if (Object.keys(filteredEnv).length > 0) {
-						const { env, secrets } = splitEnvAndSecrets(filteredEnv);
-						await projectEnvUpdate(client, {
-							id: projectId!,
-							env,
-							secrets,
-						});
-						logger.debug(
-							`Synced ${Object.keys(filteredEnv).length} environment variables to cloud`
-						);
+						if (Object.keys(filteredEnv).length > 0) {
+							const { env, secrets } = splitEnvAndSecrets(filteredEnv);
+							await projectEnvUpdate(apiClient, {
+								id: projectId as string,
+								env,
+								secrets,
+							});
+							logger.debug(
+								`Synced ${Object.keys(filteredEnv).length} environment variables to cloud`
+							);
+						}
+					} catch (error) {
+						// Non-fatal: just log the error
+						logger.debug('Failed to sync environment variables:', error);
 					}
-				} catch (error) {
-					// Non-fatal: just log the error
-					logger.debug('Failed to sync environment variables:', error);
-				}
+				},
 			});
 		}
 	}
 
-	// Step 8: Show completion message
+	// Show completion message
 	tui.success('✨ Project created successfully!\n');
 	tui.info('Next steps:');
 	if (dirName !== '.') {
-		const dirDisplay = cwd() == targetDir ? basename(dirName) : dest;
+		const dirDisplay = cwd() === targetDir ? basename(dirName) : dest;
 		tui.newline();
 		console.log(`  1. ${tui.bold(`cd ${dirDisplay}`)}`);
 		console.log(`  2. ${tui.bold('bun run dev')}`);

package/src/cmd/secret/delete.ts

@@ -2,47 +2,32 @@ import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { projectEnvDelete } from '@agentuity/server';
-import { getAPIBaseURL, APIClient } from '../../api';
-import { loadProjectConfig } from '../../config';
 import { findEnvFile, readEnvFile, writeEnvFile, filterAgentuitySdkKeys } from '../../env-util';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	aliases: ['del', 'remove', 'rm'],
 	description: 'Delete a secret',
-	requiresAuth: true,
+	requires: { auth: true, project: true, apiClient: true },
 	schema: {
 		args: z.object({
 			key: z.string().describe('the secret key to delete'),
 		}),
-		options: z.object({
-			dir: z.string().optional().describe('project directory (default: current directory)'),
-		}),
 	},
 
 	async handler(ctx) {
-		const { args, opts, config } = ctx;
-		const dir = opts?.dir ?? process.cwd();
-
-		// Load project config to get project ID
-		const projectConfig = await loadProjectConfig(dir);
-		if (!projectConfig) {
-			tui.fatal(`No Agentuity project found in ${dir}. Missing agentuity.json`);
-		}
-
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
+		const { args, apiClient, project, projectDir } = ctx;
 
 		// Delete from cloud (using secrets field)
 		await tui.spinner('Deleting secret from cloud', () => {
-			return projectEnvDelete(client, {
-				id: projectConfig.projectId,
+			return projectEnvDelete(apiClient, {
+				id: project.projectId,
 				secrets: [args.key],
 			});
 		});
 
 		// Update local .env.production file
-		const envFilePath = await findEnvFile(dir);
+		const envFilePath = await findEnvFile(projectDir);
 		const currentEnv = await readEnvFile(envFilePath);
 		delete currentEnv[args.key];
 

package/src/cmd/secret/get.ts

@@ -2,20 +2,17 @@ import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { projectGet } from '@agentuity/server';
-import { getAPIBaseURL, APIClient } from '../../api';
-import { loadProjectConfig } from '../../config';
 import { maskSecret } from '../../env-util';
 
 export const getSubcommand = createSubcommand({
 	name: 'get',
 	description: 'Get a secret value',
-	requiresAuth: true,
+	requires: { auth: true, project: true, apiClient: true },
 	schema: {
 		args: z.object({
 			key: z.string().describe('the secret key'),
 		}),
 		options: z.object({
-			dir: z.string().optional().describe('project directory (default: current directory)'),
 			mask: z
 				.boolean()
 				.default(!!process.stdout.isTTY)
@@ -24,25 +21,15 @@ export const getSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, config } = ctx;
-		const dir = opts?.dir ?? process.cwd();
-
-		// Load project config to get project ID
-		const projectConfig = await loadProjectConfig(dir);
-		if (!projectConfig) {
-			tui.fatal(`No Agentuity project found in ${dir}. Missing agentuity.json`);
-		}
-
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
+		const { args, opts, apiClient, project } = ctx;
 
 		// Fetch project with unmasked secrets
-		const project = await tui.spinner('Fetching secrets', () => {
-			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		const projectData = await tui.spinner('Fetching secrets', () => {
+			return projectGet(apiClient, { id: project.projectId, mask: false });
 		});
 
 		// Look for the key in secrets
-		const value = project.secrets?.[args.key];
+		const value = projectData.secrets?.[args.key];
 
 		if (value === undefined) {
 			tui.fatal(`Secret '${args.key}' not found`);

package/src/cmd/secret/import.ts

@@ -2,8 +2,6 @@ import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { projectEnvUpdate } from '@agentuity/server';
-import { getAPIBaseURL, APIClient } from '../../api';
-import { loadProjectConfig } from '../../config';
 import {
 	findEnvFile,
 	readEnvFile,
@@ -15,25 +13,15 @@ import {
 export const importSubcommand = createSubcommand({
 	name: 'import',
 	description: 'Import secrets from a file to cloud and local .env.production',
-	requiresAuth: true,
+	requires: { auth: true, project: true, apiClient: true },
 	schema: {
 		args: z.object({
 			file: z.string().describe('path to the .env file to import'),
 		}),
-		options: z.object({
-			dir: z.string().optional().describe('project directory (default: current directory)'),
-		}),
 	},
 
 	async handler(ctx) {
-		const { args, opts, config } = ctx;
-		const dir = opts?.dir ?? process.cwd();
-
-		// Load project config to get project ID
-		const projectConfig = await loadProjectConfig(dir);
-		if (!projectConfig) {
-			tui.fatal(`No Agentuity project found in ${dir}. Missing agentuity.json`);
-		}
+		const { args, apiClient, project, projectDir } = ctx;
 
 		// Read the import file
 		const importedSecrets = await readEnvFile(args.file);
@@ -51,19 +39,16 @@ export const importSubcommand = createSubcommand({
 			return;
 		}
 
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
-
 		// Push to cloud (using secrets field)
 		await tui.spinner('Importing secrets to cloud', () => {
-			return projectEnvUpdate(client, {
-				id: projectConfig.projectId,
+			return projectEnvUpdate(apiClient, {
+				id: project.projectId,
 				secrets: filteredSecrets,
 			});
 		});
 
 		// Merge with local .env.production file
-		const localEnvPath = await findEnvFile(dir);
+		const localEnvPath = await findEnvFile(projectDir);
 		const localEnv = await readEnvFile(localEnvPath);
 		const mergedEnv = mergeEnvVars(localEnv, filteredSecrets);
 

package/src/cmd/secret/list.ts

@@ -2,18 +2,15 @@ import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { projectGet } from '@agentuity/server';
-import { getAPIBaseURL, APIClient } from '../../api';
-import { loadProjectConfig } from '../../config';
 import { maskSecret } from '../../env-util';
 
 export const listSubcommand = createSubcommand({
 	name: 'list',
 	aliases: ['ls'],
 	description: 'List all secrets',
-	requiresAuth: true,
+	requires: { auth: true, project: true, apiClient: true },
 	schema: {
 		options: z.object({
-			dir: z.string().optional().describe('project directory (default: current directory)'),
 			mask: z
 				.boolean()
 				.default(!!process.stdout.isTTY)
@@ -22,24 +19,14 @@ export const listSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { opts, config } = ctx;
-		const dir = opts?.dir ?? process.cwd();
-
-		// Load project config to get project ID
-		const projectConfig = await loadProjectConfig(dir);
-		if (!projectConfig) {
-			tui.fatal(`No Agentuity project found in ${dir}. Missing agentuity.json`);
-		}
-
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
+		const { opts, apiClient, project } = ctx;
 
 		// Fetch project with unmasked secrets
-		const project = await tui.spinner('Fetching secrets', () => {
-			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		const projectData = await tui.spinner('Fetching secrets', () => {
+			return projectGet(apiClient, { id: project.projectId, mask: false });
 		});
 
-		const secrets = project.secrets || {};
+		const secrets = projectData.secrets || {};
 
 		if (Object.keys(secrets).length === 0) {
 			tui.info('No secrets found');