@agentuity/cli 0.0.48 → 0.0.50

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

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

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { sessionLogs } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+const SessionLogsResponseSchema = z.array(
+	z.object({
+		body: z.string().describe('Log body'),
+		severity: z.string().describe('Log severity'),
+		timestamp: z.string().describe('Log timestamp'),
+	})
+);
+
+export const logsSubcommand = createSubcommand({
+	name: 'logs',
+	description: 'Get logs for a specific session',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	examples: [`${getCommand('cloud session logs')} sess_abc123xyz`],
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
+	idempotent: true,
+	schema: {
+		args: z.object({
+			session_id: z.string().describe('Session ID'),
+		}),
+		options: z.object({
+			projectId: z.string().optional().describe('Project ID (for display purposes)'),
+			deploymentId: z.string().optional().describe('Deployment ID (for display purposes)'),
+		}),
+		response: SessionLogsResponseSchema,
+	},
+	async handler(ctx) {
+		const { apiClient, args } = ctx;
+
+		try {
+			const logs = await sessionLogs(apiClient, { id: args.session_id });
+
+			if (logs.length === 0) {
+				tui.info('No logs found for this session.');
+				return [];
+			}
+
+			tui.banner(`Logs for Session ${args.session_id}`, `${logs.length} log entries`);
+
+			for (const log of logs) {
+				const timestamp = new Date(log.timestamp).toLocaleTimeString();
+				const severity = log.severity.padEnd(5);
+				const severityColor =
+					log.severity === 'ERROR'
+						? tui.error(severity)
+						: log.severity === 'WARN'
+							? tui.warning(severity)
+							: tui.muted(severity);
+
+				console.log(`${tui.muted(timestamp)} ${severityColor} ${log.body}`);
+			}
+
+			return logs;
+		} catch (ex) {
+			tui.fatal(
+				`Failed to get session logs: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});

package/src/cmd/cloud/ssh.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { getIONHost } from '../../config';
+import { getCommand } from '../../command-prefix';
 
 const args = z.object({
 	identifier: z.string().optional().describe('The project or deployment id to use'),
@@ -15,9 +16,20 @@ const options = z.object({
 export const sshSubcommand = createSubcommand({
 	name: 'ssh',
 	description: 'SSH into a cloud project',
+	tags: ['read-only', 'slow', 'requires-auth', 'requires-deployment'],
+	idempotent: true,
+	examples: [
+		`${getCommand('cloud ssh')}                          # SSH into current project`,
+		`${getCommand('cloud ssh')} proj_abc123xyz           # SSH into specific project`,
+		`${getCommand('cloud ssh')} deploy_abc123xyz         # SSH into specific deployment`,
+		`${getCommand('cloud ssh')} 'ps aux'                 # Run command and exit`,
+		`${getCommand('cloud ssh')} proj_abc123xyz 'tail -f /var/log/app.log'`,
+		`${getCommand('cloud ssh')} --show                   # Show SSH command without executing`,
+	],
 	toplevel: true,
 	requires: { auth: true, apiClient: true },
 	optional: { project: true },
+	prerequisites: ['cloud deploy'],
 	schema: { args, options },
 
 	async handler(ctx) {

package/src/cmd/dev/agents.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { APIResponseSchema } from '@agentuity/server';
+import { abbreviate, abbreviateDescription } from '../../utils/format';
+
+const AgentSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().nullable(),
+	identifier: z.string(),
+	version: z.string().nullable(),
+	deploymentId: z.string().nullable(),
+	devmode: z.boolean(),
+	metadata: z.record(z.string(), z.unknown()).nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	evals: z.array(
+		z.object({
+			id: z.string(),
+			name: z.string(),
+			description: z.string().nullable(),
+			identifier: z.string().nullable(),
+			deploymentId: z.string().nullable(),
+			version: z.string().nullable(),
+			devmode: z.boolean(),
+			createdAt: z.string(),
+			updatedAt: z.string(),
+		})
+	),
+});
+
+const AgentsResponseSchema = APIResponseSchema(z.array(AgentSchema));
+
+export const agentsSubcommand = createSubcommand({
+	name: 'agents',
+	description: 'Show devmode agent results',
+	requires: { auth: true, apiClient: true, project: true },
+	schema: {
+		options: z.object({
+			deploymentId: z.string().optional().describe('Filter by deployment ID'),
+			format: z
+				.enum(['json', 'table'])
+				.optional()
+				.default('table')
+				.describe('Output format: json or table'),
+			verbose: z.boolean().optional().default(false).describe('Show full IDs and descriptions'),
+		}),
+	},
+	async handler(ctx) {
+		const { opts, apiClient, project } = ctx;
+		const projectId = project.projectId;
+		const format = opts?.format ?? 'table';
+		const verbose = opts?.verbose ?? false;
+
+		const deploymentId = opts?.deploymentId;
+		const queryParams = deploymentId ? `?deploymentId=${deploymentId}` : '';
+		const response = await tui.spinner('Fetching agents', async () => {
+			return apiClient.request(
+				'GET',
+				`/cli/agent/${projectId}${queryParams}`,
+				AgentsResponseSchema
+			);
+		});
+
+		if (!response.success) {
+			tui.fatal(`Failed to fetch agents: ${response.message ?? 'Unknown error'}`);
+		}
+
+		const agents = response.data;
+
+		if (format === 'json') {
+			console.log(JSON.stringify(agents, null, 2));
+			return;
+		}
+
+		tui.info(`Agents (${agents.length})`);
+		if (agents.length === 0) {
+			tui.muted('No agents found');
+		} else {
+			console.table(
+				agents.map((agent) => ({
+					name: agent.name,
+					id: verbose ? agent.id : abbreviate(agent.id, 20),
+					identifier: verbose ? agent.identifier : abbreviate(agent.identifier, 20),
+					deployment: abbreviate(agent.deploymentId, 20),
+					version: verbose
+						? (agent.version ?? 'N/A')
+						: (abbreviate(agent.version, 20) ?? 'N/A'),
+					evals: agent.evals.length,
+					createdAt: new Date(agent.createdAt).toLocaleString(),
+				})),
+				['name', 'id', 'identifier', 'deployment', 'version', 'evals', 'createdAt']
+			);
+
+			// Show evals for each agent
+			for (const agent of agents) {
+				if (agent.evals.length > 0) {
+					console.log(`\n  Evals for ${agent.name}:`);
+					console.table(
+						agent.evals.map((evalItem) => ({
+							name: evalItem.name,
+							id: verbose ? evalItem.id : abbreviate(evalItem.id, 20),
+							identifier: verbose
+								? (evalItem.identifier ?? 'N/A')
+								: (abbreviate(evalItem.identifier, 20) ?? 'N/A'),
+							deployment: abbreviate(evalItem.deploymentId, 20),
+							version: verbose
+								? (evalItem.version ?? 'N/A')
+								: (abbreviate(evalItem.version, 20) ?? 'N/A'),
+							description: verbose
+								? (evalItem.description ?? 'N/A')
+								: abbreviateDescription(evalItem.description),
+							createdAt: new Date(evalItem.createdAt).toLocaleString(),
+						})),
+						['name', 'id', 'identifier', 'deployment', 'version', 'description', 'createdAt']
+					);
+				}
+			}
+		}
+	},
+});