@agentuity/cli 0.0.42 → 0.0.44

package/src/cmd/project/delete.ts

@@ -1,17 +1,17 @@
 import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
-import { projectDelete } from '@agentuity/server';
-import { getAPIBaseURL, APIClient } from '../../api';
+import { projectDelete, projectList } from '@agentuity/server';
+import enquirer from 'enquirer';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	description: 'Delete a project',
 	aliases: ['rm', 'del'],
-	requiresAuth: true,
+	requires: { auth: true, apiClient: true },
 	schema: {
 		args: z.object({
-			id: z.string().describe('the project id'),
+			id: z.string().optional().describe('the project id'),
 		}),
 		options: z.object({
 			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
@@ -19,10 +19,56 @@ export const deleteSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, config } = ctx;
+		const { args, opts, apiClient } = ctx;
 
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
+		let projectIds: string[] = [];
+
+		if (args.id) {
+			// Command line argument provided
+			projectIds = [args.id];
+		} else {
+			// Check TTY before attempting to prompt
+			if (!process.stdin.isTTY) {
+				tui.fatal('--id is required in non-interactive mode');
+			}
+
+			// Fetch projects and prompt for selection
+			const projects = await tui.spinner({
+				message: 'Fetching projects',
+				clearOnSuccess: true,
+				callback: async () => {
+					return projectList(apiClient);
+				},
+			});
+
+			if (projects.length === 0) {
+				tui.info('No projects found to delete');
+				return;
+			}
+
+			// Sort projects by name
+			projects.sort((a, b) => a.name.localeCompare(b.name));
+
+			// Build choices for multi-select
+			const choices: Array<{ name: string; message: string }> = projects.map((project) => ({
+				name: project.id,
+				message: `${project.name.padEnd(25)} ${tui.muted(project.id)} (${project.orgName})`,
+			}));
+
+			const response = await enquirer.prompt<{ projects: string[] }>({
+				type: 'multiselect',
+				name: 'projects',
+				message: 'Select project(s) to delete:',
+				choices,
+			});
+
+			projectIds = response.projects;
+		}
+
+		if (projectIds.length === 0) {
+			tui.info('No projects selected for deletion');
+			return;
+		}
 
 		const skipConfirm = opts?.confirm === true;
 
@@ -30,25 +76,36 @@ export const deleteSubcommand = createSubcommand({
 			tui.fatal('no TTY and --confirm is false');
 		}
 
+		// Confirm deletion
 		if (!skipConfirm) {
-			const ok = await tui.confirm('Are you sure you want to delete', false);
-			if (!ok) {
+			const projectNames = projectIds.join(', ');
+			tui.warning(`You are about to delete: ${tui.bold(projectNames)}`);
+
+			const confirm = await enquirer.prompt<{ confirm: boolean }>({
+				type: 'confirm',
+				name: 'confirm',
+				message: `Are you sure you want to delete ${projectIds.length > 1 ? 'these projects' : 'this project'}?`,
+				initial: false,
+			});
+
+			if (!confirm.confirm) {
+				tui.info('Deletion cancelled');
 				return;
 			}
 		}
 
-		const deleted = await tui.spinner('Deleting project', async () => {
-			const val = await projectDelete(client!, args.id);
-			if (val.length === 1 && val[0] === args.id) {
-				return true;
-			}
-			return false;
+		const deleted = await tui.spinner({
+			message: `Deleting ${projectIds.length} project(s)`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return projectDelete(apiClient, ...projectIds);
+			},
 		});
 
-		if (deleted) {
-			tui.success(`Project ${args.id} deleted`);
+		if (deleted.length > 0) {
+			tui.success(`Deleted ${deleted.length} project(s): ${deleted.join(', ')}`);
 		} else {
-			tui.warning(`${args.id} not found`);
+			tui.error('Failed to delete projects');
 		}
 	},
 });

package/src/cmd/project/download.ts

@@ -13,7 +13,7 @@ import { tmpdir } from 'node:os';
 import { finished } from 'node:stream/promises';
 import { createGunzip } from 'node:zlib';
 import { extract, type Headers } from 'tar-fs';
-import type { Logger } from '../../logger';
+import type { Logger } from '@agentuity/core';
 import * as tui from '../../tui';
 import { downloadWithSpinner } from '../../download';
 import type { TemplateInfo } from './templates';
@@ -250,11 +250,11 @@ export async function setupProject(options: SetupOptions): Promise<void> {
 			clearOnSuccess: true,
 		});
 
-		// Create initial commit
+		// Create initial commit (disable GPG signing to avoid lock issues)
 		await tui.runCommand({
 			command: 'git commit -m "Initial Setup"',
 			cwd: dest,
-			cmd: ['git', 'commit', '-m', 'Initial Setup'],
+			cmd: ['git', '-c', 'commit.gpgsign=false', 'commit', '-m', 'Initial Setup'],
 			clearOnSuccess: true,
 		});
 	}

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,18 +7,29 @@ import enquirer from 'enquirer';
 import {
 	projectCreate,
 	projectExists,
-	listOrganizations,
-	type OrganizationList,
+	listResources,
+	projectEnvUpdate,
+	getServiceUrls,
+	APIClient as ServerAPIClient,
+	Resources,
+	createResources,
 } from '@agentuity/server';
-import type { Logger } from '../../logger';
+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 type { APIClient } from '../../api';
 import { createProjectConfig } from '../../config';
+import {
+	findEnvFile,
+	readEnvFile,
+	filterAgentuitySdkKeys,
+	splitEnvAndSecrets,
+} from '../../env-util';
+
+type ResourcesTypes = z.infer<typeof Resources>;
 
 interface CreateFlowOptions {
 	projectName?: string;
@@ -31,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> {
@@ -44,43 +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);
+		const serviceUrls = getServiceUrls();
+		const catalystUrl = config?.overrides?.catalyst_url ?? serviceUrls.catalyst;
+		catalystClient = new ServerAPIClient(catalystUrl, logger, auth.apiKey);
 	}
 
 	if (!projectName && !skipPrompts) {
@@ -93,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`;
 					}
@@ -106,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();
@@ -144,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);
 		}
@@ -181,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,
@@ -190,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,
@@ -200,29 +214,153 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		logger,
 	});
 
-	if (auth && client && orgId) {
-		await tui.spinner('Registering your project', async () => {
-			const res = await projectCreate(client, {
-				name: projectName,
-				organization_id: orgId,
-				provider: 'bunjs',
-			});
-			if (res.success && res.data) {
+	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({
+			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({
+				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(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);
+					}
+				},
+			});
+		}
 	}
 
-	// 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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectEnvDelete } from '@agentuity/server';
+import { findEnvFile, readEnvFile, writeEnvFile, filterAgentuitySdkKeys } from '../../env-util';
+
+export const deleteSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['del', 'remove', 'rm'],
+	description: 'Delete a secret',
+	requires: { auth: true, project: true, apiClient: true },
+	schema: {
+		args: z.object({
+			key: z.string().describe('the secret key to delete'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, apiClient, project, projectDir } = ctx;
+
+		// Delete from cloud (using secrets field)
+		await tui.spinner('Deleting secret from cloud', () => {
+			return projectEnvDelete(apiClient, {
+				id: project.projectId,
+				secrets: [args.key],
+			});
+		});
+
+		// Update local .env.production file
+		const envFilePath = await findEnvFile(projectDir);
+		const currentEnv = await readEnvFile(envFilePath);
+		delete currentEnv[args.key];
+
+		// Filter out AGENTUITY_ keys before writing
+		const filteredEnv = filterAgentuitySdkKeys(currentEnv);
+		await writeEnvFile(envFilePath, filteredEnv);
+
+		tui.success(`Secret '${args.key}' deleted successfully (cloud + ${envFilePath})`);
+	},
+});

package/src/cmd/secret/get.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectGet } from '@agentuity/server';
+import { maskSecret } from '../../env-util';
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Get a secret value',
+	requires: { auth: true, project: true, apiClient: true },
+	schema: {
+		args: z.object({
+			key: z.string().describe('the secret key'),
+		}),
+		options: z.object({
+			mask: z
+				.boolean()
+				.default(!!process.stdout.isTTY)
+				.describe('mask the value in output (default: true in TTY, false otherwise)'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, opts, apiClient, project } = ctx;
+
+		// Fetch project with unmasked secrets
+		const projectData = await tui.spinner('Fetching secrets', () => {
+			return projectGet(apiClient, { id: project.projectId, mask: false });
+		});
+
+		// Look for the key in secrets
+		const value = projectData.secrets?.[args.key];
+
+		if (value === undefined) {
+			tui.fatal(`Secret '${args.key}' not found`);
+		}
+
+		if (process.stdout.isTTY) {
+			// Display the value, masked by default
+			if (opts?.mask) {
+				tui.success(`${args.key}=${maskSecret(value)}`);
+			} else {
+				tui.success(`${args.key}=${value}`);
+			}
+		} else {
+			// Display the value, masked by default
+			if (opts?.mask) {
+				console.log(`${args.key}=${maskSecret(value)}`);
+			} else {
+				console.log(`${args.key}=${value}`);
+			}
+		}
+	},
+});