@agentuity/cli 0.0.41 → 0.0.43

package/src/cli.ts

@@ -15,7 +15,7 @@ export async function createCLI(version: string): Promise<Command> {
 
 	program
 		.option('--config <path>', 'Config file path', '~/.config/agentuity/production.yaml')
-		.option('--log-level <level>', 'Log level', 'info')
+		.option('--log-level <level>', 'Log level', process.env.AGENTUITY_LOG_LEVEL ?? 'info')
 		.option('--log-timestamp', 'Show timestamps in log output', false)
 		.option('--no-log-prefix', 'Hide log level prefixes', false)
 		.option('--color-scheme <scheme>', 'Color scheme: light or dark');
@@ -69,9 +69,14 @@ async function registerSubcommand(
 			if (opt.type === 'boolean') {
 				// Support negatable boolean options (--no-flag) when they have a default
 				if (opt.hasDefault) {
+					// Evaluate default value (could be a function)
+					const defaultValue =
+						typeof opt.defaultValue === 'function' ? opt.defaultValue() : opt.defaultValue;
 					cmd.option(`--no-${flag}`, desc);
+					cmd.option(`--${flag}`, desc, defaultValue);
+				} else {
+					cmd.option(`--${flag}`, desc);
 				}
-				cmd.option(`--${flag}`, desc);
 			} else if (opt.type === 'number') {
 				cmd.option(`--${flag} <${opt.name}>`, desc, parseFloat);
 			} else {
@@ -108,10 +113,22 @@ async function registerSubcommand(
 						const issues = (error as { issues: Array<{ path: string[]; message: string }> })
 							.issues;
 						for (const issue of issues) {
-							baseCtx.logger.error(`  ${issue.path.join('.')}: ${issue.message}`);
+							baseCtx.logger.error(
+								`  ${issue.path?.length ? issue.path.join('.') + ': ' : ''}${issue.message}`
+							);
 						}
 						process.exit(1);
 					}
+					if (
+						error &&
+						typeof error === 'object' &&
+						'name' in error &&
+						error.name === 'ProjectConfigNotFoundExpection'
+					) {
+						baseCtx.logger.fatal(
+							'invalid project folder. use --dir to specify a different directory or change to a project folder'
+						);
+					}
 					throw error;
 				}
 			} else {
@@ -146,10 +163,22 @@ async function registerSubcommand(
 						const issues = (error as { issues: Array<{ path: string[]; message: string }> })
 							.issues;
 						for (const issue of issues) {
-							baseCtx.logger.error(`  ${issue.path.join('.')}: ${issue.message}`);
+							baseCtx.logger.error(
+								`  ${issue.path?.length ? issue.path.join('.') + ': ' : ''}${issue.message}`
+							);
 						}
 						process.exit(1);
 					}
+					if (
+						error &&
+						typeof error === 'object' &&
+						'name' in error &&
+						error.name === 'ProjectConfigNotFoundExpection'
+					) {
+						baseCtx.logger.fatal(
+							'invalid project folder. use --dir to specify a different directory or change to a project folder'
+						);
+					}
 					throw error;
 				}
 			} else {
@@ -176,10 +205,22 @@ async function registerSubcommand(
 						const issues = (error as { issues: Array<{ path: string[]; message: string }> })
 							.issues;
 						for (const issue of issues) {
-							baseCtx.logger.error(`  ${issue.path.join('.')}: ${issue.message}`);
+							baseCtx.logger.error(
+								`  ${issue.path?.length ? issue.path.join('.') + ': ' : ''}${issue.message}`
+							);
 						}
 						process.exit(1);
 					}
+					if (
+						error &&
+						typeof error === 'object' &&
+						'name' in error &&
+						error.name === 'ProjectConfigNotFoundExpection'
+					) {
+						baseCtx.logger.fatal(
+							'invalid project folder. use --dir to specify a different directory or change to a project folder'
+						);
+					}
 					throw error;
 				}
 			} else {

package/src/cmd/auth/index.ts

@@ -2,9 +2,10 @@ import { createCommand } from '../../types';
 import { loginCommand } from './login';
 import { logoutCommand } from './logout';
 import { signupCommand } from './signup';
+import { whoamiCommand } from './whoami';
 
 export const command = createCommand({
 	name: 'auth',
 	description: 'Authentication and authorization related commands',
-	subcommands: [loginCommand, logoutCommand, signupCommand],
+	subcommands: [loginCommand, logoutCommand, signupCommand, whoamiCommand],
 });

package/src/cmd/auth/login.ts

@@ -16,10 +16,8 @@ export const loginCommand = createSubcommand({
 		const appUrl = getAppBaseURL(config);
 
 		try {
-			let otp: string | undefined;
-
-			await tui.spinner('Generating login one time code...', async () => {
-				otp = await generateLoginOTP(apiUrl, config);
+			const otp = await tui.spinner('Generating login one time code...', () => {
+				return generateLoginOTP(apiUrl, config);
 			});
 
 			if (!otp) {

package/src/cmd/auth/whoami.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { whoami } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
+
+export const whoamiCommand = createSubcommand({
+	name: 'whoami',
+	description: 'Display information about the currently authenticated user',
+	requiresAuth: true,
+	schema: {
+		options: z.object({
+			format: z
+				.enum(['json', 'table'])
+				.optional()
+				.describe('the output format: json, table (default)'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { config, opts, auth } = ctx;
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		const result = await tui.spinner('Fetching user information', () => {
+			return whoami(client!);
+		});
+
+		if (!result.data) {
+			tui.fatal('Failed to get user information');
+		}
+
+		const user = result.data;
+
+		if (opts?.format === 'json') {
+			console.log(
+				JSON.stringify(
+					{
+						userId: auth?.userId,
+						firstName: user.firstName,
+						lastName: user.lastName,
+						organizations: user.organizations,
+					},
+					null,
+					2
+				)
+			);
+		} else {
+			const fullName = `${user.firstName} ${user.lastName}`;
+
+			tui.newline();
+			console.log(tui.bold('Currently logged in as:'));
+			tui.newline();
+			console.log(`  ${tui.padRight('Name:', 15, ' ')} ${tui.bold(fullName)}`);
+			console.log(`  ${tui.padRight('User ID:', 15, ' ')} ${tui.muted(auth?.userId || '')}`);
+			tui.newline();
+
+			if (user.organizations.length > 0) {
+				console.log(tui.bold('Organizations:'));
+				tui.newline();
+				for (const org of user.organizations) {
+					console.log(`  ${tui.padRight(org.name, 30, ' ')} ${tui.muted(org.id)}`);
+				}
+			}
+			tui.newline();
+		}
+	},
+});

package/src/cmd/bundle/ast.ts

@@ -1,6 +1,7 @@
 import * as acornLoose from 'acorn-loose';
 import { basename, dirname, relative } from 'node:path';
 import { generate } from 'astring';
+import { BuildMetadata } from '../../types';
 
 interface ASTNode {
 	type: string;
@@ -12,9 +13,7 @@ interface ASTNodeIdentifier extends ASTNode {
 
 interface ASTCallExpression extends ASTNode {
 	arguments: unknown[];
-	callee: {
-		name: string;
-	};
+	callee: ASTMemberExpression;
 }
 
 interface ASTPropertyNode {
@@ -31,10 +30,22 @@ interface ASTObjectExpression extends ASTNode {
 	properties: ASTPropertyNode[];
 }
 
-interface ASTLiteral {
+interface ASTLiteral extends ASTNode {
 	value: string;
 }
 
+interface ASTMemberExpression extends ASTNode {
+	object: ASTNode;
+	property: ASTNode;
+	computed: boolean;
+	optional: boolean;
+	name?: string;
+}
+
+interface ASTExpressionStatement extends ASTNode {
+	expression: ASTCallExpression;
+}
+
 function parseObjectExpressionToMap(expr: ASTObjectExpression): Map<string, string> {
 	const result = new Map<string, string>();
 	for (const prop of expr.properties) {
@@ -98,6 +109,10 @@ function getAgentId(identifier: string): string {
 	return hash(projectId, identifier);
 }
 
+function generateRouteId(method: string, path: string): string {
+	return hash(projectId, method, path);
+}
+
 type AcornParseResultType = ReturnType<typeof acornLoose.parse>;
 
 function augmentAgentMetadataNode(
@@ -229,3 +244,153 @@ export function parseAgentMetadata(
 		`error parsing: ${filename}. could not find an proper createAgent defined in this file`
 	);
 }
+
+type RouteDefinition = BuildMetadata['routes'];
+
+export async function parseRoute(
+	rootDir: string,
+	filename: string
+): Promise<BuildMetadata['routes']> {
+	const contents = await Bun.file(filename).text();
+	const version = hash(contents);
+	const ast = acornLoose.parse(contents, { ecmaVersion: 'latest', sourceType: 'module' });
+	let exportName: string | undefined;
+	let variableName: string | undefined;
+	for (const body of ast.body) {
+		if (body.type === 'ExportDefaultDeclaration') {
+			const identifier = body.declaration as ASTNodeIdentifier;
+			exportName = identifier.name;
+			break;
+		}
+	}
+	if (!exportName) {
+		throw new Error(`could not find default export for ${filename} using ${rootDir}`);
+	}
+	for (const body of ast.body) {
+		if (body.type === 'VariableDeclaration') {
+			for (const vardecl of body.declarations) {
+				if (vardecl.type === 'VariableDeclarator' && vardecl.id.type === 'Identifier') {
+					const identifier = vardecl.id as ASTNodeIdentifier;
+					if (identifier.name === exportName) {
+						if (vardecl.init?.type === 'CallExpression') {
+							const call = vardecl.init as ASTCallExpression;
+							if (call.callee.name === 'createRouter') {
+								variableName = identifier.name;
+								break;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if (!variableName) {
+		throw new Error(
+			`error parsing: ${filename}. could not find an proper createRouter defined in this file`
+		);
+	}
+
+	const rel = relative(rootDir, filename);
+	const name = basename(dirname(filename));
+	const routes: RouteDefinition = [];
+	const routePrefix = filename.includes('src/agents') ? '/agent' : '/api';
+
+	for (const body of ast.body) {
+		if (body.type === 'ExpressionStatement') {
+			const statement = body as ASTExpressionStatement;
+			const callee = statement.expression.callee;
+			if (callee.object.type === 'Identifier') {
+				const identifier = callee.object as ASTNodeIdentifier;
+				if (identifier.name === variableName) {
+					let method = (callee.property as ASTNodeIdentifier).name;
+					let type = 'api';
+					const action = statement.expression.arguments[0];
+					let suffix = '';
+					let config: Record<string, unknown> | undefined;
+					switch (method) {
+						case 'get':
+						case 'put':
+						case 'post':
+						case 'patch':
+						case 'delete': {
+							const theaction = action as ASTLiteral;
+							if (theaction.type === 'Literal') {
+								suffix = theaction.value;
+								break;
+							}
+							break;
+						}
+						case 'stream':
+						case 'sse':
+						case 'websocket': {
+							type = method;
+							method = 'post';
+							const theaction = action as ASTLiteral;
+							if (theaction.type === 'Literal') {
+								suffix = theaction.value;
+								break;
+							}
+							break;
+						}
+						case 'sms': {
+							type = method;
+							method = 'post';
+							const theaction = action as ASTObjectExpression;
+							if (theaction.type === 'ObjectExpression') {
+								config = {};
+								theaction.properties.forEach((p) => {
+									if (p.value.type === 'Literal') {
+										const literal = p.value as ASTLiteral;
+										config![p.key.name] = literal.value;
+									}
+								});
+								const number = theaction.properties.find((p) => p.key.name === 'number');
+								if (number && number.value.type === 'Literal') {
+									const phoneNumber = number.value as ASTLiteral;
+									suffix = hash(phoneNumber.value);
+									break;
+								}
+							}
+							break;
+						}
+						case 'email': {
+							type = method;
+							method = 'post';
+							const theaction = action as ASTLiteral;
+							if (theaction.type === 'Literal') {
+								const email = theaction.value;
+								suffix = hash(email);
+								break;
+							}
+							break;
+						}
+						case 'cron': {
+							type = method;
+							method = 'post';
+							const theaction = action as ASTLiteral;
+							if (theaction.type === 'Literal') {
+								const number = theaction.value;
+								suffix = hash(number);
+								break;
+							}
+							break;
+						}
+					}
+					const thepath = `${routePrefix}/${name}/${suffix}`
+						.replaceAll(/\/{2,}/g, '/')
+						.replaceAll(/\/$/g, '');
+					routes.push({
+						id: generateRouteId(method, thepath),
+						method: method as 'get' | 'post' | 'put' | 'delete' | 'patch',
+						type: type as 'api' | 'sms' | 'email' | 'cron',
+						filename: rel,
+						path: thepath,
+						version,
+						config,
+					});
+				}
+			}
+		}
+	}
+	return routes;
+}

package/src/cmd/bundle/index.ts

@@ -1,9 +1,9 @@
-import { createSubcommand } from '../../types';
+import { createCommand } from '../../types';
 import { z } from 'zod';
 import { resolve } from 'node:path';
 import { bundle } from './bundler';
 
-export const command = createSubcommand({
+export const command = createCommand({
 	name: 'bundle',
 	description: 'Bundle Agentuity application for deployment',
 	aliases: ['build'],

package/src/cmd/bundle/plugin.ts

@@ -1,7 +1,8 @@
 import type { BunPlugin } from 'bun';
 import { dirname, basename, join } from 'node:path';
 import { existsSync, writeFileSync } from 'node:fs';
-import { parseAgentMetadata } from './ast';
+import type { BuildMetadata } from '../../types';
+import { parseAgentMetadata, parseRoute } from './ast';
 import { applyPatch, generatePatches } from './patch';
 
 function toCamelCase(str: string): string {
@@ -115,6 +116,7 @@ const AgentuityBundler: BunPlugin = {
 			Map<string, string>
 		>();
 		const transpiler = new Bun.Transpiler({ loader: 'ts' });
+		let routeDefinitions: BuildMetadata['routes'] = [];
 
 		build.onResolve({ filter: /\/route\.ts$/, namespace: 'file' }, async (args) => {
 			if (args.path.startsWith(srcDir)) {
@@ -194,6 +196,9 @@ const AgentuityBundler: BunPlugin = {
 						.replace('/agents', '/agent')
 						.replace('./', '/');
 
+					const definitions = await parseRoute(rootDir, join(srcDir, route + '.ts'));
+					routeDefinitions = [...routeDefinitions, ...definitions];
+
 					let agentDetail: Record<string, string> = {};
 
 					if (hasAgent) {
@@ -264,6 +269,42 @@ const AgentuityBundler: BunPlugin = {
 					contents += `\n${inserts.join('\n')}`;
 				}
 
+				// generate the build metadata
+				const metadata: BuildMetadata = {
+					routes: routeDefinitions,
+					agents: [],
+				};
+				for (const [, v] of agentMetadata) {
+					if (!v.has('filename')) {
+						throw new Error('agent metadata is missing expected filename property');
+					}
+					if (!v.has('id')) {
+						throw new Error('agent metadata is missing expected id property');
+					}
+					if (!v.has('identifier')) {
+						throw new Error('agent metadata is missing expected identifier property');
+					}
+					if (!v.has('version')) {
+						throw new Error('agent metadata is missing expected version property');
+					}
+					if (!v.has('name')) {
+						throw new Error('agent metadata is missing expected name property');
+					}
+					metadata.agents.push({
+						filename: v.get('filename')!,
+						id: v.get('id')!,
+						identifier: v.get('identifier')!,
+						version: v.get('version')!,
+						name: v.get('name')!,
+						description: v.get('description') ?? '<no description provided>',
+					});
+				}
+
+				const metadataFilename = Bun.file(
+					join(build.config.outdir!, 'agentuity.metadata.json')
+				);
+				await metadataFilename.write(JSON.stringify(metadata));
+
 				return {
 					contents,
 					loader: 'ts',

package/src/cmd/cloud/deploy.ts

@@ -0,0 +1,129 @@
+import { createSubcommand } from '../../types';
+import { z } from 'zod';
+import { join } from 'node:path';
+import * as tui from '../../tui';
+import { loadProjectConfig, saveProjectDir } from '../../config';
+import { runSteps, stepSuccess, stepSkipped, stepError } from '../../steps';
+import { bundle } from '../bundle/bundler';
+import { loadBuildMetadata } from '../../config';
+import { projectEnvUpdate } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
+import {
+	findEnvFile,
+	readEnvFile,
+	filterAgentuitySdkKeys,
+	splitEnvAndSecrets,
+} from '../../env-util';
+
+export const deploySubcommand = createSubcommand({
+	name: 'deploy',
+	description: 'Deploy project to the Agentuity Cloud',
+	toplevel: true,
+	requiresAuth: true,
+	schema: {
+		options: z.object({
+			dir: z.string().optional().describe('Directory to use for the project'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { opts, config } = ctx;
+		const dir = opts?.dir ?? process.cwd();
+		try {
+			const project = await loadProjectConfig(dir);
+			if (!project) {
+				console.log(project); // FIXME
+			}
+			await saveProjectDir(dir);
+
+			const apiUrl = getAPIBaseURL(config);
+			const client = new APIClient(apiUrl, config);
+
+			await runSteps([
+				{
+					label: 'Sync Environment Variables',
+					run: async () => {
+						try {
+							// Read local env file (.env.production or .env)
+							const envFilePath = await findEnvFile(dir);
+							const localEnv = await readEnvFile(envFilePath);
+
+							// Filter out AGENTUITY_ keys
+							const filteredEnv = filterAgentuitySdkKeys(localEnv);
+
+							if (Object.keys(filteredEnv).length === 0) {
+								return stepSkipped('no environment variables to sync');
+							}
+
+							// Split into env and secrets
+							const { env, secrets } = splitEnvAndSecrets(filteredEnv);
+
+							// Push to cloud
+							await projectEnvUpdate(client, {
+								id: project.projectId,
+								env,
+								secrets,
+							});
+
+							return stepSuccess();
+						} catch (ex) {
+							// Non-fatal: log warning but continue deployment
+							const _ex = ex as Error;
+							return stepSkipped(_ex.message ?? 'failed to sync env variables');
+						}
+					},
+				},
+				{
+					label: 'Create Deployment',
+					run: async () => {
+						// TODO: implement
+						await Bun.sleep(1500);
+						return stepSuccess();
+					},
+				},
+				{
+					label: 'Build, Verify and Package',
+					run: async () => {
+						try {
+							await bundle({
+								rootDir: dir,
+								dev: false,
+							});
+							await loadBuildMetadata(join(dir, '.agentuity'));
+							return stepSuccess();
+						} catch (ex) {
+							const _ex = ex as Error;
+							return stepError(_ex.message ?? 'Error building your project');
+						}
+					},
+				},
+				{
+					label: 'Encrypt and Upload Deployment',
+					run: async () => {
+						// TODO: implement
+						await Bun.sleep(800);
+						return stepSkipped('already up to date');
+					},
+				},
+				{
+					label: 'Provision Services',
+					run: async () => {
+						// TODO: implement
+						await Bun.sleep(1200);
+						return stepSuccess();
+					},
+				},
+			]);
+			tui.success('Your project was deployed!');
+			tui.arrow(tui.link('https://project-123455666332.agentuity.run'));
+		} catch (ex) {
+			const _ex = ex as Error;
+			if (_ex.name === 'ProjectConfigNotFoundExpection') {
+				tui.fatal(
+					`The directory ${dir} does not contain a valid Agentuity project. Missing agentuity.json`
+				);
+			}
+			tui.fatal(`unxpected error trying to deploy project. ${ex}`);
+		}
+	},
+});

package/src/cmd/cloud/index.ts

@@ -0,0 +1,8 @@
+import { createCommand } from '../../types';
+import { deploySubcommand } from './deploy';
+
+export const command = createCommand({
+	name: 'cloud',
+	description: 'Cloud related commands',
+	subcommands: [deploySubcommand],
+});