@agentuity/cli 0.0.49 → 0.0.50

package/src/cmd/bundle/ast.ts

@@ -116,6 +116,10 @@ function hashSHA1(...val: string[]): string {
 	return hasher.digest().toHex();
 }
 
+export function getDevmodeDeploymentId(projectId: string, endpointId: string): string {
+	return `devmode_${hashSHA1(projectId, endpointId)}`;
+}
+
 function getAgentId(
 	projectId: string,
 	deploymentId: string,
@@ -151,6 +155,10 @@ function generateStableAgentId(projectId: string, name: string): string {
 	return `agentid_${hashSHA1(projectId, name)}`.substring(0, 64);
 }
 
+function generateStableEvalId(projectId: string, agentId: string, name: string): string {
+	return `evalid_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
+}
+
 type AcornParseResultType = ReturnType<typeof acornLoose.parse>;
 
 function augmentAgentMetadataNode(
@@ -242,14 +250,29 @@ function setLiteralValue(literal: ASTLiteral, value: string) {
 }
 
 function augmentEvalMetadataNode(
+	projectId: string,
+	agentId: string,
 	id: string,
 	name: string,
 	rel: string,
 	version: string,
-	identifier: string,
-	metadataObj: ASTObjectExpression
+	_ast: AcornParseResultType,
+	metadataObj: ASTObjectExpression,
+	_filename: string
 ): void {
-	// Check if id, version, identifier, filename already exist
+	const metadata = parseObjectExpressionToMap(metadataObj);
+	// Name can come from metadata.name or variable name (already resolved in caller)
+	// If metadata doesn't have name, we'll add it from the resolved name
+	if (!metadata.has('name')) {
+		metadataObj.properties.push(createObjectPropertyNode('name', name));
+	}
+	const descriptionNode = metadataObj.properties.find((x) => x.key.name === 'description')?.value;
+	const description = descriptionNode ? (descriptionNode as ASTLiteral).value : '';
+	const effectiveAgentId = agentId || '';
+	const _evalId = getEvalId(projectId, effectiveAgentId, rel, name, version); // Deployment-specific ID (not used, kept for potential future use)
+	const stableEvalId = generateStableEvalId(projectId, effectiveAgentId, name);
+
+	// Check if id, version, identifier, filename, evalId already exist
 	const existingKeys = new Set<string>();
 	for (const prop of metadataObj.properties) {
 		if (prop.key.type === 'Identifier') {
@@ -286,12 +309,12 @@ function augmentEvalMetadataNode(
 	}
 
 	if (!existingKeys.has('identifier')) {
-		metadataObj.properties.push(createObjectPropertyNode('identifier', identifier));
+		metadataObj.properties.push(createObjectPropertyNode('identifier', name));
 	} else {
 		for (const prop of metadataObj.properties) {
 			if (prop.key.type === 'Identifier' && prop.key.name === 'identifier') {
 				if (prop.value.type === 'Literal') {
-					setLiteralValue(prop.value as ASTLiteral, identifier);
+					setLiteralValue(prop.value as ASTLiteral, name);
 				}
 				break;
 			}
@@ -310,6 +333,32 @@ function augmentEvalMetadataNode(
 			}
 		}
 	}
+
+	if (!existingKeys.has('evalId')) {
+		metadataObj.properties.push(createObjectPropertyNode('evalId', stableEvalId));
+	} else {
+		for (const prop of metadataObj.properties) {
+			if (prop.key.type === 'Identifier' && prop.key.name === 'evalId') {
+				if (prop.value.type === 'Literal') {
+					setLiteralValue(prop.value as ASTLiteral, stableEvalId);
+				}
+				break;
+			}
+		}
+	}
+
+	if (!existingKeys.has('description')) {
+		metadataObj.properties.push(createObjectPropertyNode('description', description));
+	} else {
+		for (const prop of metadataObj.properties) {
+			if (prop.key.type === 'Identifier' && prop.key.name === 'description') {
+				if (prop.value.type === 'Literal') {
+					setLiteralValue(prop.value as ASTLiteral, description);
+				}
+				break;
+			}
+		}
+	}
 }
 
 export function parseEvalMetadata(
@@ -317,7 +366,8 @@ export function parseEvalMetadata(
 	filename: string,
 	contents: string,
 	projectId: string,
-	deploymentId: string
+	deploymentId: string,
+	agentId?: string
 ): [
 	string,
 	Array<{
@@ -326,6 +376,7 @@ export function parseEvalMetadata(
 		version: string;
 		identifier: string;
 		name: string;
+		evalId: string;
 		description?: string;
 	}>,
 ] {
@@ -339,8 +390,6 @@ export function parseEvalMetadata(
 	logger.trace(`Parsing evals from ${filename}`);
 	const ast = acornLoose.parse(contents, { ecmaVersion: 'latest', sourceType: 'module' });
 	const rel = relative(rootDir, filename);
-	const dir = dirname(filename);
-	const identifier = basename(dir);
 	const version = hash(contents);
 	const evals: Array<{
 		filename: string;
@@ -348,17 +397,16 @@ export function parseEvalMetadata(
 		version: string;
 		identifier: string;
 		name: string;
+		evalId: string;
 		description?: string;
 	}> = [];
 
-	// Find all agent.createEval() calls
+	// Find all exported agent.createEval() calls
 	for (const body of ast.body) {
 		let variableDeclaration: { declarations: Array<ASTVariableDeclarator> } | undefined;
 
-		// Handle both direct VariableDeclaration and ExportNamedDeclaration
-		if (body.type === 'VariableDeclaration') {
-			variableDeclaration = body as { declarations: Array<ASTVariableDeclarator> };
-		} else if (body.type === 'ExportNamedDeclaration') {
+		// Only process exported VariableDeclarations
+		if (body.type === 'ExportNamedDeclaration') {
 			const exportDecl = body as {
 				declaration?: { type: string; declarations?: Array<ASTVariableDeclarator> };
 			};
@@ -447,14 +495,31 @@ export function parseEvalMetadata(
 									);
 
 									// Inject metadata into AST if metadata object exists
+									let stableEvalId: string;
+									const effectiveAgentId = agentId || '';
 									if (metadataObj) {
 										augmentEvalMetadataNode(
+											projectId,
+											effectiveAgentId,
 											evalId,
 											finalName,
 											rel,
 											version,
-											identifier,
-											metadataObj
+											ast,
+											metadataObj,
+											filename
+										);
+										// Extract evalId from metadata after augmentation
+										const metadata = parseObjectExpressionToMap(metadataObj);
+										stableEvalId =
+											metadata.get('evalId') ||
+											generateStableEvalId(projectId, effectiveAgentId, finalName);
+									} else {
+										// If no metadata object, generate stable evalId
+										stableEvalId = generateStableEvalId(
+											projectId,
+											effectiveAgentId,
+											finalName
 										);
 									}
 
@@ -462,8 +527,9 @@ export function parseEvalMetadata(
 										filename: rel,
 										id: evalId,
 										version,
-										identifier,
+										identifier: finalName,
 										name: finalName,
+										evalId: stableEvalId,
 										description: evalDescription,
 									});
 								}
@@ -639,12 +705,14 @@ export async function parseAgentMetadata(
 		const evalsSource = await evalsFile.text();
 		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
 		const evalsContents = transpiler.transformSync(evalsSource);
+		const agentId = result[1].get('agentId') || '';
 		const [, evals] = parseEvalMetadata(
 			rootDir,
 			evalsPath,
 			evalsContents,
 			projectId,
-			deploymentId
+			deploymentId,
+			agentId
 		);
 		if (evals.length > 0) {
 			logger.trace(`Adding ${evals.length} eval(s) to agent metadata for ${name}`);

package/src/cmd/bundle/plugin.ts

@@ -578,6 +578,7 @@ const AgentuityBundler: BunPlugin = {
 						version: v.get('version')!,
 						name: v.get('name')!,
 						description: v.get('description') ?? '<no description provided>',
+						projectId,
 					};
 
 					const evalsStr = v.get('evals');
@@ -586,7 +587,17 @@ const AgentuityBundler: BunPlugin = {
 							`[plugin] Found evals string for agent ${agentData.name}, parsing...`
 						);
 						try {
-							agentData.evals = JSON.parse(evalsStr);
+							const parsedEvals = JSON.parse(evalsStr) as Array<
+								Omit<
+									NonNullable<BuildMetadata['agents'][number]['evals']>[number],
+									'agentIdentifier' | 'projectId'
+								>
+							>;
+							agentData.evals = parsedEvals.map((evalItem) => ({
+								...evalItem,
+								agentIdentifier: agentData.agentId,
+								projectId,
+							}));
 							logger.trace(
 								`[plugin] Successfully parsed ${agentData.evals?.length ?? 0} eval(s) for agent ${agentData.name}`
 							);
@@ -614,6 +625,7 @@ const AgentuityBundler: BunPlugin = {
 								version: sub.get('version')!,
 								name: sub.get('name')!,
 								description: sub.get('description') ?? '<no description provided>',
+								projectId,
 							};
 
 							// Add evals for subagents if any
@@ -623,7 +635,17 @@ const AgentuityBundler: BunPlugin = {
 									`[plugin] Found evals string for subagent ${subagentData.name}, parsing...`
 								);
 								try {
-									subagentData.evals = JSON.parse(subEvalsStr);
+									const parsedSubEvals = JSON.parse(subEvalsStr) as Array<
+										Omit<
+											NonNullable<BuildMetadata['agents'][number]['evals']>[number],
+											'agentIdentifier' | 'projectId'
+										>
+									>;
+									subagentData.evals = parsedSubEvals.map((evalItem) => ({
+										...evalItem,
+										agentIdentifier: subagentData.agentId,
+										projectId,
+									}));
 									logger.trace(
 										`[plugin] Successfully parsed ${subagentData.evals?.length ?? 0} eval(s) for subagent ${subagentData.name}`
 									);

package/src/cmd/cloud/deployment/list.ts

@@ -3,7 +3,6 @@ import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectDeploymentList } from '@agentuity/server';
 import { resolveProjectId } from './utils';
-import { Table } from 'console-table-printer';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 
@@ -64,28 +63,23 @@ export const listSubcommand = createSubcommand({
 				return [];
 			}
 
-			const table = new Table({
-				columns: [
-					{ name: 'ID', alignment: 'left' },
-					{ name: 'State', alignment: 'left' },
-					{ name: 'Active', alignment: 'center' },
-					{ name: 'Created', alignment: 'left' },
-					{ name: 'Message', alignment: 'left' },
-					{ name: 'Tags', alignment: 'left' },
-				],
-			});
+			const tableData = deployments.map((d) => ({
+				ID: d.id,
+				State: d.state || 'unknown',
+				Active: d.active ? 'Yes' : '',
+				Created: new Date(d.createdAt).toLocaleString(),
+				Message: d.message || '',
+				Tags: d.tags.join(', '),
+			}));
 
-			for (const d of deployments) {
-				table.addRow({
-					ID: d.id,
-					State: d.state || 'unknown',
-					Active: d.active ? 'Yes' : '',
-					Created: new Date(d.createdAt).toLocaleString(),
-					Message: d.message || '',
-					Tags: d.tags.join(', '),
-				});
-			}
-			table.printTable();
+			tui.table(tableData, [
+				{ name: 'ID', alignment: 'left' },
+				{ name: 'State', alignment: 'left' },
+				{ name: 'Active', alignment: 'center' },
+				{ name: 'Created', alignment: 'left' },
+				{ name: 'Message', alignment: 'left' },
+				{ name: 'Tags', alignment: 'left' },
+			]);
 
 			return deployments.map((d) => ({
 				id: d.id,

package/src/cmd/cloud/index.ts

@@ -1,6 +1,7 @@
 import { createCommand } from '../../types';
 import { deploySubcommand } from './deploy';
 import { resourceSubcommand } from './resource';
+import { sessionCommand } from './session';
 import { sshSubcommand } from './ssh';
 import { scpSubcommand } from './scp';
 import { deploymentCommand } from './deployment';
@@ -12,6 +13,7 @@ export const command = createCommand({
 	subcommands: [
 		deploySubcommand,
 		resourceSubcommand,
+		sessionCommand,
 		sshSubcommand,
 		scpSubcommand,
 		deploymentCommand,

package/src/cmd/cloud/session/get.ts

@@ -0,0 +1,164 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { sessionGet } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { getCatalystAPIClient } from '../../../config';
+
+const SessionGetResponseSchema = z.object({
+	id: z.string().describe('Session ID'),
+	created_at: z.string().describe('Creation timestamp'),
+	start_time: z.string().describe('Start time'),
+	end_time: z.string().nullable().describe('End time'),
+	duration: z.number().nullable().describe('Duration in nanoseconds'),
+	org_id: z.string().describe('Organization ID'),
+	project_id: z.string().describe('Project ID'),
+	deployment_id: z.string().describe('Deployment ID'),
+	agent_ids: z.array(z.string()).describe('Agent IDs'),
+	trigger: z.string().describe('Trigger type'),
+	env: z.string().describe('Environment'),
+	devmode: z.boolean().describe('Dev mode'),
+	pending: z.boolean().describe('Pending'),
+	success: z.boolean().describe('Success'),
+	error: z.string().nullable().describe('Error message'),
+	method: z.string().describe('HTTP method'),
+	url: z.string().describe('Request URL'),
+	route_id: z.string().describe('Route ID'),
+	thread_id: z.string().describe('Thread ID'),
+	agentNames: z.array(z.string()).describe('Agent names'),
+	evalRuns: z.array(z.object({
+		id: z.string(),
+		created_at: z.string(),
+		eval_id: z.string(),
+		pending: z.boolean(),
+		success: z.boolean(),
+		error: z.string().nullable(),
+		result: z.string().nullable(),
+	})).describe('Eval runs'),
+});
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Get details about a specific session',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [`${getCommand('cloud session get')} sess_abc123xyz`],
+	requires: { auth: true },
+	idempotent: true,
+	schema: {
+		args: z.object({
+			session_id: z.string().describe('Session ID'),
+		}),
+		response: SessionGetResponseSchema,
+	},
+	async handler(ctx) {
+		const { config, logger, auth, args, options } = ctx;
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		try {
+			const enriched = await sessionGet(catalystClient, { id: args.session_id });
+			const session = enriched.session;
+
+			const result = {
+				id: session.id,
+				created_at: session.created_at,
+				start_time: session.start_time,
+				end_time: session.end_time,
+				duration: session.duration,
+				org_id: session.org_id,
+				project_id: session.project_id,
+				deployment_id: session.deployment_id,
+				agent_ids: session.agent_ids,
+				trigger: session.trigger,
+				env: session.env,
+				devmode: session.devmode,
+				pending: session.pending,
+				success: session.success,
+				error: session.error,
+				method: session.method,
+				url: session.url,
+				route_id: session.route_id,
+				thread_id: session.thread_id,
+				agentNames: enriched.agentNames,
+				evalRuns: enriched.evalRuns.map(run => ({
+					id: run.id,
+					eval_id: run.eval_id,
+					created_at: run.created_at,
+					pending: run.pending,
+					success: run.success,
+					error: run.error,
+					result: run.result,
+				})),
+			};
+
+			if (options.json) {
+				console.log(JSON.stringify(result, null, 2));
+				return result;
+			}
+
+			tui.banner(`Session ${session.id}`, `Status: ${session.success ? 'Success' : 'Failed'}`);
+
+			console.log(tui.bold('ID:          ') + session.id);
+			console.log(tui.bold('Project:     ') + session.project_id);
+			console.log(tui.bold('Deployment:  ') + (session.deployment_id || '-'));
+			console.log(tui.bold('Created:     ') + new Date(session.created_at).toLocaleString());
+			console.log(tui.bold('Start:       ') + new Date(session.start_time).toLocaleString());
+			if (session.end_time) {
+				console.log(tui.bold('End:         ') + new Date(session.end_time).toLocaleString());
+			}
+			if (session.duration) {
+				console.log(
+					tui.bold('Duration:    ') + `${(session.duration / 1_000_000).toFixed(0)}ms`
+				);
+			}
+			console.log(tui.bold('Method:      ') + session.method);
+			console.log(tui.bold('URL:         ') + tui.link(session.url, session.url));
+			console.log(tui.bold('Trigger:     ') + session.trigger);
+			console.log(tui.bold('Environment: ') + session.env);
+			console.log(tui.bold('Dev Mode:    ') + (session.devmode ? 'Yes' : 'No'));
+			console.log(tui.bold('Success:     ') + (session.success ? '✓' : '✗'));
+			console.log(tui.bold('Pending:     ') + (session.pending ? 'Yes' : 'No'));
+			if (session.error) {
+				console.log(tui.bold('Error:       ') + tui.error(session.error));
+			}
+			if (enriched.agentNames.length > 0) {
+				const agentDisplay = enriched.agentNames.map((name, idx) => {
+					const agentId = session.agent_ids[idx];
+					return `${name} ${tui.muted(`(${agentId})`)}`;
+				}).join(', ');
+				console.log(tui.bold('Agents:      ') + agentDisplay);
+			}
+			console.log(tui.bold('Route ID:    ') + session.route_id);
+			console.log(tui.bold('Thread ID:   ') + session.thread_id);
+
+			if (enriched.evalRuns.length > 0) {
+				console.log('');
+				console.log(tui.bold('Eval Runs:'));
+				const evalTableData = enriched.evalRuns.map((run) => ({
+					ID: run.id,
+					'Eval ID': run.eval_id,
+					Success: run.success ? '✓' : '✗',
+					Pending: run.pending ? '⏳' : '✓',
+					Error: run.error || 'No',
+					Created: new Date(run.created_at).toLocaleString(),
+				}));
+
+				tui.table(evalTableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Eval ID', alignment: 'left' },
+					{ name: 'Success', alignment: 'center' },
+					{ name: 'Pending', alignment: 'center' },
+					{ name: 'Error', alignment: 'left' },
+					{ name: 'Created', alignment: 'left' },
+				]);
+			}
+
+			return result;
+		} catch (ex) {
+			tui.fatal(
+				`Failed to get session: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});

package/src/cmd/cloud/session/index.ts

@@ -0,0 +1,11 @@
+import { createCommand } from '../../../types';
+import { getSubcommand } from './get';
+import { listSubcommand } from './list';
+import { logsSubcommand } from './logs';
+
+export const sessionCommand = createCommand({
+	name: 'session',
+	description: 'Manage sessions',
+	tags: ['requires-auth'],
+	subcommands: [getSubcommand, listSubcommand, logsSubcommand],
+});

package/src/cmd/cloud/session/list.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { sessionList } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { getCatalystAPIClient } from '../../../config';
+
+const SessionListResponseSchema = z.array(
+	z.object({
+		id: z.string().describe('Session ID'),
+		created_at: z.string().describe('Creation timestamp'),
+		success: z.boolean().describe('Whether the session succeeded'),
+		duration: z.number().nullable().describe('Duration in nanoseconds'),
+		method: z.string().describe('HTTP method'),
+		url: z.string().describe('Request URL'),
+		trigger: z.string().describe('Trigger type'),
+		env: z.string().describe('Environment'),
+	})
+);
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	description: 'List recent sessions',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [
+		`${getCommand('cloud session list')}                      # List 10 most recent sessions`,
+		`${getCommand('cloud session list')} --count=25           # List 25 most recent sessions`,
+		`${getCommand('cloud session list')} --project-id=proj_* # Filter by project`,
+		`${getCommand('cloud session list')} --deployment-id=*   # Filter by deployment`,
+		`${getCommand('cloud session list')} --success=true      # Only successful sessions`,
+		`${getCommand('cloud session list')} --devmode=false     # Only production sessions`,
+		`${getCommand('cloud session list')} --trigger=api       # Only API triggered sessions`,
+		`${getCommand('cloud session list')} --env=production    # Only production environment`,
+	],
+	aliases: ['ls'],
+	requires: { auth: true },
+	optional: { project: true },
+	idempotent: true,
+	pagination: {
+		supported: true,
+		defaultLimit: 10,
+		maxLimit: 100,
+		parameters: {
+			limit: 'count',
+		},
+	},
+	schema: {
+		options: z.object({
+			count: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.max(100)
+				.default(10)
+				.describe('Number of sessions to list (1–100)'),
+			projectId: z.string().optional().describe('Filter by project ID'),
+			deploymentId: z.string().optional().describe('Filter by deployment ID'),
+			trigger: z.string().optional().describe('Filter by trigger type (api, cron, webhook)'),
+			env: z.string().optional().describe('Filter by environment'),
+			threadId: z.string().optional().describe('Filter by thread ID'),
+			agentIdentifier: z.string().optional().describe('Filter by agent identifier'),
+			devmode: z.coerce.boolean().optional().describe('Filter by dev mode (true/false)'),
+			success: z.coerce.boolean().optional().describe('Filter by success status (true/false)'),
+			startAfter: z.string().optional().describe('Filter by start time after (ISO 8601)'),
+			startBefore: z.string().optional().describe('Filter by start time before (ISO 8601)'),
+		}),
+		response: SessionListResponseSchema,
+	},
+	async handler(ctx) {
+		const { config, logger, auth, project, opts, options } = ctx;
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+		
+		const projectId = opts.projectId || project?.projectId;
+
+		try {
+			const sessions = await sessionList(catalystClient, {
+				count: opts.count,
+				projectId,
+				deploymentId: opts.deploymentId,
+				trigger: opts.trigger,
+				env: opts.env,
+				devmode: opts.devmode,
+				success: opts.success,
+				threadId: opts.threadId,
+				agentIdentifier: opts.agentIdentifier,
+				startAfter: opts.startAfter,
+				startBefore: opts.startBefore,
+			});
+
+			const result = sessions.map((s) => ({
+				id: s.id,
+				created_at: s.created_at,
+				success: s.success,
+				duration: s.duration,
+				method: s.method,
+				url: s.url,
+				trigger: s.trigger,
+				env: s.env,
+			}));
+
+			if (options.json) {
+				console.log(JSON.stringify(result, null, 2));
+				return result;
+			}
+
+			if (sessions.length === 0) {
+				tui.info('No sessions found.');
+				return [];
+			}
+
+			const tableData = sessions.map((s) => {
+				const urlPath = new URL(s.url).pathname;
+				return {
+					ID: s.id,
+					Created: new Date(s.created_at).toLocaleString(),
+					Success: s.success ? '✓' : '✗',
+					Duration: s.duration ? `${(s.duration / 1_000_000).toFixed(0)}ms` : '-',
+					Method: s.method,
+					Path: urlPath.length > 50 ? urlPath.substring(0, 47) + '...' : urlPath,
+					Trigger: s.trigger,
+					Env: s.env,
+				};
+			});
+
+			tui.table(tableData, [
+				{ name: 'ID', alignment: 'left' },
+				{ name: 'Created', alignment: 'left' },
+				{ name: 'Success', alignment: 'center' },
+				{ name: 'Duration', alignment: 'right' },
+				{ name: 'Method', alignment: 'left' },
+				{ name: 'Path', alignment: 'left' },
+				{ name: 'Trigger', alignment: 'left' },
+				{ name: 'Env', alignment: 'left' },
+			]);
+
+			return result;
+		} catch (ex) {
+			tui.fatal(
+				`Failed to list sessions: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});