@agentuity/cli 0.0.43 → 0.0.45

package/src/cmd/env/delete.ts

@@ -2,8 +2,6 @@ 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 {
 	findExistingEnvFile,
 	readEnvFile,
@@ -15,39 +13,26 @@ export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	aliases: ['del', 'remove', 'rm'],
 	description: 'Delete an environment variable',
-	requiresAuth: true,
+	requires: { auth: true, project: true, apiClient: true },
 	schema: {
 		args: z.object({
 			key: z.string().describe('the environment variable 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, project, projectDir, apiClient } = ctx;
 
 		// Delete from cloud
 		await tui.spinner('Deleting environment variable from cloud', () => {
-			return projectEnvDelete(client, {
-				id: projectConfig.projectId,
+			return projectEnvDelete(apiClient, {
+				id: project.projectId,
 				env: [args.key],
 			});
 		});
 
 		// Update local .env file (prefer .env.production, fallback to .env)
-		const envFilePath = await findExistingEnvFile(dir);
+		const envFilePath = await findExistingEnvFile(projectDir);
 		const currentEnv = await readEnvFile(envFilePath);
 		delete currentEnv[args.key];
 

package/src/cmd/env/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 an environment variable value',
-	requiresAuth: true,
+	requires: { auth: true, project: true, apiClient: true },
 	schema: {
 		args: z.object({
 			key: z.string().describe('the environment variable key'),
 		}),
 		options: z.object({
-			dir: z.string().optional().describe('project directory (default: current directory)'),
 			mask: z
 				.boolean()
 				.default(false)
@@ -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 environment variables', () => {
-			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		const projectData = await tui.spinner('Fetching environment variables', () => {
+			return projectGet(apiClient, { id: project.projectId, mask: false });
 		});
 
 		// Look for the key in env
-		const value = project.env?.[args.key];
+		const value = projectData.env?.[args.key];
 
 		if (value === undefined) {
 			tui.fatal(`Environment variable '${args.key}' not found`);

package/src/cmd/env/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,
@@ -18,25 +16,15 @@ import { getCommand } from '../../command-prefix';
 export const importSubcommand = createSubcommand({
 	name: 'import',
 	description: 'Import environment variables 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 importedEnv = await readEnvFile(args.file);
@@ -85,23 +73,20 @@ export const importSubcommand = createSubcommand({
 			}
 		}
 
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
-
 		// Split into env and secrets based on key naming conventions
 		const { env: normalEnv, secrets } = splitEnvAndSecrets(filteredEnv);
 
 		// Push to cloud
 		await tui.spinner('Importing environment variables to cloud', () => {
-			return projectEnvUpdate(client, {
-				id: projectConfig.projectId,
+			return projectEnvUpdate(apiClient, {
+				id: project.projectId,
 				env: normalEnv,
 				secrets: secrets,
 			});
 		});
 
 		// 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, filteredEnv);
 

package/src/cmd/env/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 environment variables',
-	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(false)
@@ -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 environment variables', () => {
-			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		const projectData = await tui.spinner('Fetching environment variables', () => {
+			return projectGet(apiClient, { id: project.projectId, mask: false });
 		});
 
-		const env = project.env || {};
+		const env = projectData.env || {};
 
 		if (Object.keys(env).length === 0) {
 			tui.info('No environment variables found');

package/src/cmd/env/pull.ts

@@ -3,8 +3,6 @@ import { join } from 'node:path';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { projectGet } from '@agentuity/server';
-import { getAPIBaseURL, APIClient } from '../../api';
-import { loadProjectConfig } from '../../config';
 import {
 	findEnvFile,
 	findExistingEnvFile,
@@ -16,40 +14,29 @@ import {
 export const pullSubcommand = createSubcommand({
 	name: 'pull',
 	description: 'Pull environment variables from cloud to local .env.production file',
-	requiresAuth: true,
+	requires: { auth: true, project: true, apiClient: true },
 	schema: {
 		options: z.object({
-			dir: z.string().optional().describe('project directory (default: current directory)'),
 			force: z.boolean().default(false).describe('overwrite local values with cloud values'),
 		}),
 	},
 
 	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, projectDir } = ctx;
 
 		// Fetch project with unmasked secrets
-		const project = await tui.spinner('Pulling environment variables from cloud', () => {
-			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		const projectData = await tui.spinner('Pulling environment variables from cloud', () => {
+			return projectGet(apiClient, { id: project.projectId, mask: false });
 		});
 
-		const cloudEnv = project.env || {};
+		const cloudEnv = projectData.env || {};
 
 		// Read current local env from existing file (.env.production or .env)
-		const existingEnvPath = await findExistingEnvFile(dir);
+		const existingEnvPath = await findExistingEnvFile(projectDir);
 		const localEnv = await readEnvFile(existingEnvPath);
 
 		// Target file is always .env.production
-		const targetEnvPath = await findEnvFile(dir);
+		const targetEnvPath = await findEnvFile(projectDir);
 
 		// Merge: cloud values override local if force=true, otherwise keep local
 		let mergedEnv: Record<string, string>;
@@ -67,12 +54,12 @@ export const pullSubcommand = createSubcommand({
 		});
 
 		// Write AGENTUITY_SDK_KEY to .env if present and missing locally
-		if (project.api_key) {
-			const dotEnvPath = join(dir, '.env');
+		if (projectData.api_key) {
+			const dotEnvPath = join(projectDir, '.env');
 			const dotEnv = await readEnvFile(dotEnvPath);
 
 			if (!dotEnv.AGENTUITY_SDK_KEY) {
-				dotEnv.AGENTUITY_SDK_KEY = project.api_key;
+				dotEnv.AGENTUITY_SDK_KEY = projectData.api_key;
 				await writeEnvFile(dotEnvPath, dotEnv, {
 					addComment: (key) => {
 						if (key === 'AGENTUITY_SDK_KEY') {

package/src/cmd/env/push.ts

@@ -1,33 +1,18 @@
-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 { findExistingEnvFile, readEnvFile, filterAgentuitySdkKeys } from '../../env-util';
 
 export const pushSubcommand = createSubcommand({
 	name: 'push',
 	description: 'Push environment variables from local .env.production file to cloud',
-	requiresAuth: true,
-	schema: {
-		options: z.object({
-			dir: z.string().optional().describe('project directory (default: current directory)'),
-		}),
-	},
+	requires: { auth: true, project: true, apiClient: true },
 
 	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 { apiClient, project, projectDir } = ctx;
 
 		// Read local env file (prefer .env.production, fallback to .env)
-		const envFilePath = await findExistingEnvFile(dir);
+		const envFilePath = await findExistingEnvFile(projectDir);
 		const localEnv = await readEnvFile(envFilePath);
 
 		// Filter out AGENTUITY_ prefixed keys (don't push SDK keys)
@@ -38,13 +23,10 @@ export const pushSubcommand = createSubcommand({
 			return;
 		}
 
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
-
 		// Push to cloud
 		await tui.spinner('Pushing environment variables to cloud', () => {
-			return projectEnvUpdate(client, {
-				id: projectConfig.projectId,
+			return projectEnvUpdate(apiClient, {
+				id: project.projectId,
 				env: filteredEnv,
 			});
 		});

package/src/cmd/env/set.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,
@@ -16,20 +14,16 @@ import { getCommand } from '../../command-prefix';
 export const setSubcommand = createSubcommand({
 	name: 'set',
 	description: 'Set an environment variable',
-	requiresAuth: true,
+	requires: { auth: true, project: true, apiClient: true },
 	schema: {
 		args: z.object({
 			key: z.string().describe('the environment variable key'),
 			value: z.string().describe('the environment variable value'),
 		}),
-		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();
+		const { args, apiClient, project, projectDir } = ctx;
 
 		// Validate key doesn't start with AGENTUITY_
 		if (args.key.startsWith('AGENTUITY_')) {
@@ -55,25 +49,16 @@ export const setSubcommand = createSubcommand({
 			}
 		}
 
-		// 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);
-
 		// Set in cloud
 		await tui.spinner('Setting environment variable in cloud', () => {
-			return projectEnvUpdate(client, {
-				id: projectConfig.projectId,
+			return projectEnvUpdate(apiClient, {
+				id: project.projectId,
 				env: { [args.key]: args.value },
 			});
 		});
 
 		// Update local .env.production file
-		const envFilePath = await findEnvFile(dir);
+		const envFilePath = await findEnvFile(projectDir);
 		const currentEnv = await readEnvFile(envFilePath);
 		currentEnv[args.key] = args.value;
 

package/src/cmd/index.ts

@@ -27,8 +27,8 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 									description: subcommand.description,
 									aliases: subcommand.aliases,
 									hidden: true,
-									requiresAuth: subcommand.requiresAuth,
-									optionalAuth: subcommand.optionalAuth,
+									requires: subcommand.requires,
+									optional: subcommand.optional,
 									schema: subcommand.schema,
 									handler: subcommand.handler,
 								};

package/src/cmd/profile/show.ts

@@ -1,6 +1,6 @@
 import { createSubcommand } from '../../types';
 import { z } from 'zod';
-import { getProfile, fetchProfiles } from '../../config';
+import { getProfile, fetchProfiles, loadConfig } from '../../config';
 import { readFile } from 'node:fs/promises';
 import * as tui from '../../tui';
 
@@ -9,6 +9,9 @@ export const showCommand = createSubcommand({
 	description: 'Show the configuration of a profile (defaults to current)',
 	aliases: ['current'],
 	schema: {
+		options: z.object({
+			json: z.boolean().optional().describe('Show the JSON config'),
+		}),
 		args: z
 			.object({
 				name: z.string().optional().describe('Profile name to show (optional)'),
@@ -17,10 +20,11 @@ export const showCommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args } = ctx;
+		const { logger, args, opts } = ctx;
 
 		try {
 			let profilePath: string;
+			let current = false;
 
 			if (args.name) {
 				// Find profile by name
@@ -33,16 +37,21 @@ export const showCommand = createSubcommand({
 
 				profilePath = profile.filename;
 			} else {
+				current = true;
 				// Use current profile
 				profilePath = await getProfile();
 			}
 
-			const content = await readFile(profilePath, 'utf-8');
-
 			tui.info(`Profile: ${profilePath}`);
-			tui.newline();
 
-			console.log(content);
+			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);
+			}
 		} catch (error) {
 			if (error instanceof Error) {
 				logger.fatal(`Failed to show profile: ${error.message}`);

package/src/cmd/project/create.ts

@@ -6,8 +6,10 @@ export const createProjectSubcommand = createSubcommand({
 	name: 'create',
 	description: 'Create a new project',
 	aliases: ['new'],
+	banner: true,
 	toplevel: true,
-	optionalAuth: true,
+	optional: { auth: true, org: true, region: true },
+	requires: { apiClient: true },
 	schema: {
 		options: z.object({
 			name: z.string().optional().describe('Project name'),
@@ -41,7 +43,7 @@ export const createProjectSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, opts, auth, config } = ctx;
+		const { logger, opts, auth, config, apiClient, orgId, region } = ctx;
 
 		await runCreateFlow({
 			projectName: opts.name,
@@ -55,6 +57,9 @@ export const createProjectSubcommand = createSubcommand({
 			logger,
 			auth: opts.register === true ? auth : undefined,
 			config: config!,
+			apiClient,
+			orgId,
+			region,
 		});
 	},
 });

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

@@ -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,
 		});
 	}