@agentuity/cli 0.1.13 → 0.1.15

package/src/cmd/dev/index.ts

@@ -175,8 +175,8 @@ export const command = createCommand({
 	optional: { project: true },
 
 	async handler(ctx) {
-		const { opts, logger, project, projectDir } = ctx;
-		let { config } = ctx;
+		const { opts, logger, projectDir } = ctx;
+		let { config, project } = ctx;
 
 		// Get auth state - we handle auth ourselves based on project state
 		let auth = await getAuth();
@@ -227,7 +227,9 @@ export const command = createCommand({
 					tui.newline();
 
 					const shouldLogin = await tui.confirm(
-						hasProfile ? 'Would you like to login now?' : 'Would you like to login or create an account?',
+						hasProfile
+							? 'Would you like to login now?'
+							: 'Would you like to login or create an account?',
 						true
 					);
 
@@ -272,9 +274,63 @@ export const command = createCommand({
 					);
 				}
 			}
+
+			// After auth is established, verify project access
+			if (auth && config) {
+				const { reconcileProject } = await import('../project/reconcile');
+				const apiClient = new APIClient(getAPIBaseURL(config), logger, auth.apiKey, config);
+
+				const result = await reconcileProject({
+					dir: rootDir,
+					auth,
+					apiClient,
+					config,
+					logger,
+					interactive: isTTY(),
+				});
+
+				if (result.status === 'error') {
+					tui.fatal(result.message!, ErrorCode.PROJECT_NOT_FOUND);
+				} else if (result.status === 'imported' && result.project) {
+					// Project was re-imported to user's org
+					project = result.project;
+					tui.newline();
+				} else if (result.status === 'skipped') {
+					// User declined import - can't continue with cloud features
+					tui.warning('Continuing in local-only mode.');
+					project = undefined;
+				}
+			}
 		} else {
-			// No agentuity.json - local-only mode, ignore auth state
-			tui.showLocalOnlyWarning();
+			// No agentuity.json - check if this is a valid project that needs importing
+			if (auth && config) {
+				const { reconcileProject } = await import('../project/reconcile');
+				const apiClient = new APIClient(getAPIBaseURL(config), logger, auth.apiKey, config);
+
+				const result = await reconcileProject({
+					dir: rootDir,
+					auth,
+					apiClient,
+					config,
+					logger,
+					interactive: isTTY(),
+				});
+
+				if (result.status === 'error') {
+					// Not a valid project - show local-only warning
+					tui.showLocalOnlyWarning();
+				} else if (result.status === 'imported' && result.project) {
+					// Project was imported - reload project config
+					project = result.project;
+					tui.newline();
+				} else if (result.status === 'skipped') {
+					// User declined import - continue in local-only mode
+					tui.showLocalOnlyWarning();
+				}
+			} else {
+				// Not authenticated - local-only mode
+				tui.showLocalOnlyWarning();
+			}
 		}
 
 		// Prepare dev lock: cleans up stale processes from previous sessions
@@ -924,6 +980,7 @@ export const command = createCommand({
 					}
 
 					process.env.AGENTUITY_SDK_DEV_MODE = 'true';
+					process.env.AGENTUITY_RUNTIME = 'yes';
 					process.env.AGENTUITY_ENV = 'development';
 					process.env.NODE_ENV = 'development';
 					process.env.AGENTUITY_PROJECT_DIR = rootDir;

package/src/cmd/help/index.ts

@@ -1,5 +1,6 @@
 import { createCommand } from '../../types';
 import { getCommand } from '../../command-prefix';
+import { getProgram } from '../../program-ref';
 
 export const command = createCommand({
 	name: 'help',
@@ -13,28 +14,13 @@ export const command = createCommand({
 	idempotent: true,
 
 	async handler() {
-		// Spawn the CLI with no arguments to show help
-		let spawnArgs: string[];
-
-		if (process.env.AGENTUITY_CLI_VERSION) {
-			// Compiled binary: spawn only the binary executable with no additional args
-			spawnArgs = [process.argv[0]];
-		} else {
-			// Script mode: spawn runtime and script, omitting the 'help' argument
-			spawnArgs = [process.argv[0], ...(process.argv.length > 1 ? [process.argv[1]] : [])];
-		}
-
-		const proc = Bun.spawn(spawnArgs, {
-			stdio: ['inherit', 'inherit', 'inherit'],
-			env: process.env,
-		});
-
-		const exitCode = await proc.exited;
-
-		if (exitCode !== 0) {
-			throw new Error(`Help command exited with code ${exitCode}`);
+		// Get the root program and display its help
+		// This avoids spawning a subprocess which doesn't work reliably
+		// with Bun compiled binaries
+		const program = getProgram();
+		if (program) {
+			program.outputHelp();
 		}
-
-		return undefined;
+		process.exit(0);
 	},
 });

package/src/cmd/project/create.ts

@@ -6,9 +6,11 @@ import type { APIClient as APIClientType } from '../../api';
 
 const ProjectCreateResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
+	error: z.string().optional().describe('Error message if setup failed'),
 	name: z.string().describe('Project name'),
 	path: z.string().describe('Project directory path'),
 	projectId: z.string().optional().describe('Project ID if registered'),
+	orgId: z.string().optional().describe('Organization ID if registered'),
 	template: z.string().describe('Template used'),
 	installed: z.boolean().describe('Whether dependencies were installed'),
 	built: z.boolean().describe('Whether the project was built'),
@@ -72,7 +74,7 @@ export const createProjectSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, opts, auth, config, apiClient, region } = ctx;
+		const { logger, opts, auth, config, apiClient, region, options } = ctx;
 
 		// Only get org if registering
 		let orgId: string | undefined;
@@ -83,7 +85,7 @@ export const createProjectSubcommand = createSubcommand({
 			);
 		}
 
-		await runCreateFlow({
+		const result = await runCreateFlow({
 			projectName: opts.name,
 			dir: opts.dir,
 			domains: opts.domains,
@@ -101,14 +103,22 @@ export const createProjectSubcommand = createSubcommand({
 			region,
 		});
 
-		// Return best-effort response (runCreateFlow doesn't return values)
+		// Exit with error code if setup failed and not in JSON mode
+		if (!result.success && !options.json) {
+			process.exitCode = 1;
+		}
+
 		return {
-			success: true,
-			name: opts.name || 'project',
-			path: opts.dir || process.cwd(),
-			template: opts.template || 'default',
-			installed: opts.install !== false,
-			built: opts.build !== false,
+			success: result.success,
+			error: result.error,
+			name: result.name,
+			path: result.path,
+			projectId: result.projectId,
+			orgId: result.orgId,
+			template: result.template,
+			installed: result.installed,
+			built: result.built,
+			domains: result.domains,
 		};
 	},
 });

package/src/cmd/project/download.ts

@@ -328,8 +328,9 @@ export async function downloadTemplate(options: DownloadOptions): Promise<void>
 	}
 }
 
-export async function setupProject(options: SetupOptions): Promise<void> {
+export async function setupProject(options: SetupOptions): Promise<{ success: boolean }> {
 	const { dest, projectName, dirName, noInstall, noBuild, logger } = options;
+	let hasError = false;
 
 	// Replace {{PROJECT_NAME}} in files
 	tui.info(`🔧 Setting up ${projectName}...`);
@@ -345,6 +346,7 @@ export async function setupProject(options: SetupOptions): Promise<void> {
 		});
 		if (exitCode !== 0) {
 			logger.error('Failed to install dependencies');
+			hasError = true;
 		}
 	}
 
@@ -361,6 +363,7 @@ export async function setupProject(options: SetupOptions): Promise<void> {
 			});
 			if (exitCode !== 0) {
 				logger.error('Template setup script failed');
+				hasError = true;
 			}
 		} finally {
 			// Always delete the setup script after running (or attempting to run)
@@ -382,12 +385,15 @@ export async function setupProject(options: SetupOptions): Promise<void> {
 		});
 		if (exitCode !== 0) {
 			logger.error('Failed to build project');
+			hasError = true;
 		}
 	}
 
 	// Generate and write AGENTS.md files for the CLI and source folders
 	// Always overwrite during project setup to ensure fresh content
 	await writeAgentsDocs(dest);
+
+	return { success: !hasError };
 }
 
 export async function initGitRepo(dest: string): Promise<void> {

package/src/cmd/project/import.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import { resolve } from 'node:path';
+import { createSubcommand } from '../../types';
+import { getCommand } from '../../command-prefix';
+import { runProjectImport } from './reconcile';
+import * as tui from '../../tui';
+import { ErrorCode } from '../../errors';
+import { isTTY } from '../../auth';
+
+const ProjectImportResponseSchema = z.object({
+	success: z.boolean().describe('Whether the import succeeded'),
+	projectId: z.string().optional().describe('Project ID if imported'),
+	orgId: z.string().optional().describe('Organization ID'),
+	region: z.string().optional().describe('Region'),
+	status: z
+		.enum(['valid', 'imported', 'skipped', 'error'])
+		.describe('The result status of the import'),
+	message: z.string().optional().describe('Status message'),
+});
+
+export const importSubcommand = createSubcommand({
+	name: 'import',
+	description: 'Import or register a local project with Agentuity Cloud',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	examples: [
+		{ command: getCommand('project import'), description: 'Import project in current directory' },
+		{
+			command: getCommand('project import --dir ./my-agent'),
+			description: 'Import project from specified directory',
+		},
+	],
+	requires: { auth: true, apiClient: true },
+	optional: { region: true },
+	schema: {
+		options: z.object({
+			dir: z
+				.string()
+				.optional()
+				.describe('Directory containing the project (default: current directory)'),
+			validateOnly: z
+				.boolean()
+				.optional()
+				.describe('Only validate the project structure without prompting'),
+		}),
+		response: ProjectImportResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, auth, apiClient, config, logger } = ctx;
+
+		if (!config) {
+			tui.fatal('Configuration not loaded. Please try again.', ErrorCode.CONFIG_INVALID);
+		}
+
+		const dir = opts.dir ? resolve(opts.dir) : process.cwd();
+		const validateOnly = opts.validateOnly ?? false;
+
+		const result = await runProjectImport({
+			dir,
+			auth,
+			apiClient,
+			config,
+			logger,
+			interactive: validateOnly ? false : isTTY(),
+			validateOnly,
+		});
+
+		if (result.status === 'error') {
+			tui.fatal(result.message ?? 'Failed to import project', ErrorCode.PROJECT_NOT_FOUND);
+		}
+
+		if (result.status === 'skipped') {
+			tui.info(result.message || 'Import cancelled.');
+			return {
+				success: false,
+				status: result.status,
+				message: result.message,
+			};
+		}
+
+		// Show success message for validateOnly mode
+		if (validateOnly && result.status === 'valid' && !result.project) {
+			tui.success(result.message || 'Project structure is valid.');
+		}
+
+		return {
+			success: result.status === 'valid' || result.status === 'imported',
+			projectId: result.project?.projectId,
+			orgId: result.project?.orgId,
+			region: result.project?.region,
+			status: result.status,
+			message:
+				result.status === 'imported'
+					? 'Project imported successfully'
+					: result.message || 'Project is already registered',
+		};
+	},
+});

package/src/cmd/project/index.ts

@@ -1,5 +1,6 @@
 import { createCommand } from '../../types';
 import { createProjectSubcommand } from './create';
+import { importSubcommand } from './import';
 import { listSubcommand } from './list';
 import { deleteSubcommand } from './delete';
 import { showSubcommand } from './show';
@@ -12,11 +13,13 @@ export const command = createCommand({
 	tags: ['fast', 'requires-auth'],
 	examples: [
 		{ command: getCommand('project create my-agent'), description: 'Create a new project' },
+		{ command: getCommand('project import'), description: 'Import an existing project' },
 		{ command: getCommand('project list'), description: 'List all projects' },
 		{ command: getCommand('project auth init'), description: 'Set up Agentuity Auth' },
 	],
 	subcommands: [
 		createProjectSubcommand,
+		importSubcommand,
 		listSubcommand,
 		deleteSubcommand,
 		showSubcommand,