@agentuity/cli 0.0.57 → 0.0.59

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

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectAgentList } from '@agentuity/server';
+import Table from 'cli-table3';
+import { abbreviate, abbreviateDescription } from '../../../utils/format';
+import { getCommand } from '../../../command-prefix';
+import { AgentSchema } from './schema';
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	description: 'List agents for a project',
+	aliases: ['ls'],
+	requires: { auth: true, apiClient: true, project: true },
+	examples: [
+		getCommand('cloud agent list'),
+		getCommand('cloud agent list --verbose'),
+		getCommand('--json cloud agent list'),
+	],
+	schema: {
+		options: z.object({
+			deploymentId: z.string().optional().describe('Filter by deployment ID'),
+			verbose: z.boolean().optional().default(false).describe('Show full descriptions'),
+		}),
+		response: z.array(AgentSchema),
+	},
+	async handler(ctx) {
+		const { opts, apiClient, project, options } = ctx;
+		const projectId = project.projectId;
+		const verbose = opts?.verbose ?? false;
+
+		const agents = await tui.spinner({
+			message: 'Fetching agents',
+			clearOnSuccess: true,
+			callback: async () => {
+				return projectAgentList(apiClient, projectId, {
+					deploymentId: opts?.deploymentId,
+				});
+			},
+		});
+
+		if (options.json) {
+			return agents;
+		}
+
+		tui.info(`Agents (${agents.length})`);
+		if (agents.length === 0) {
+			console.log(tui.muted('No agents found'));
+		} else {
+			const table = new Table({
+				head: [
+					tui.heading('Name'),
+					tui.heading('ID'),
+					tui.heading('Description'),
+					tui.heading('Evals'),
+					tui.heading('Created'),
+				],
+				colAligns: ['left', 'left', 'left', 'center', 'left'],
+				wordWrap: true,
+			});
+
+			for (const agent of agents) {
+				table.push([
+					agent.name,
+					agent.identifier,
+					verbose ? (agent.description ?? 'N/A') : abbreviateDescription(agent.description),
+					agent.evals.length,
+					new Date(agent.createdAt).toLocaleString(),
+				]);
+			}
+			console.log(table.toString());
+
+			// Show evals for each agent
+			for (const agent of agents) {
+				if (agent.evals.length > 0) {
+					console.log(`\n  Evals for ${agent.name}:`);
+					const evalTable = new Table({
+						head: [
+							tui.heading('Name'),
+							tui.heading('ID'),
+							tui.heading('Description'),
+							tui.heading('Created'),
+						],
+						colAligns: ['left', 'left', 'left', 'left'],
+						wordWrap: true,
+					});
+
+					for (const evalItem of agent.evals) {
+						evalTable.push([
+							evalItem.name,
+							verbose
+								? (evalItem.identifier ?? 'N/A')
+								: (abbreviate(evalItem.identifier, 20) ?? 'N/A'),
+							verbose
+								? (evalItem.description ?? 'N/A')
+								: abbreviateDescription(evalItem.description),
+							new Date(evalItem.createdAt).toLocaleString(),
+						]);
+					}
+					console.log(evalTable.toString());
+				}
+			}
+		}
+
+		return agents;
+	},
+});

package/src/cmd/cloud/agent/schema.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import type { Agent } from '@agentuity/server';
+
+export const AgentSchema: z.ZodType<Agent> = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().nullable(),
+	identifier: z.string(),
+	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(),
+			devmode: z.boolean(),
+			createdAt: z.string(),
+			updatedAt: z.string(),
+		})
+	),
+});

package/src/cmd/cloud/apikey/create.ts

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+import { createSubcommand as createSubcommandHelper } from '../../../types';
+import * as tui from '../../../tui';
+import { apikeyCreate } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { parseExpiresAt } from '../../../utils/date';
+
+const APIKeyCreateResponseSchema = z.object({
+	id: z.string().describe('the API key id'),
+	value: z.string().describe('the API key value'),
+});
+
+export const createSubcommand = createSubcommandHelper({
+	name: 'create',
+	aliases: ['new'],
+	description: 'Create a new API key',
+	tags: ['destructive', 'creates-resource', 'slow', 'requires-auth'],
+	examples: [
+		getCommand('cloud apikey create --name "My API Key" --expires-at 1y'),
+		getCommand('cloud apikey create --name "Short-lived Key" --expires-at 30d'),
+		getCommand(
+			'cloud apikey create --name "Production Key" --expires-at 2026-01-01T00:00:00Z --confirm'
+		),
+	],
+	requires: { auth: true, apiClient: true, org: true },
+	optional: { project: true },
+	idempotent: false,
+	schema: {
+		options: z.object({
+			name: z.string().describe('the name for the API key'),
+			'expires-at': z
+				.string()
+				.describe(
+					'expiration date as ISO 8601 (2025-12-31T23:59:59Z) or duration (1h, 2d, 30d, 1y)'
+				),
+			confirm: z
+				.boolean()
+				.optional()
+				.describe('Skip confirmation prompts (required for non-TTY)'),
+		}),
+		response: APIKeyCreateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, apiClient, project, orgId, options } = ctx;
+
+		const skipConfirm = opts?.confirm === true;
+
+		const projectId = project?.projectId ?? null;
+
+		// Parse expires-at (duration or ISO date)
+		let expiresAt: string;
+		try {
+			expiresAt = parseExpiresAt(opts['expires-at']);
+		} catch (error) {
+			if (error instanceof Error) {
+				tui.fatal(error.message);
+			}
+			throw error;
+		}
+
+		// Require --confirm flag when not in a TTY
+		if (!process.stdout.isTTY && !skipConfirm) {
+			tui.fatal('--confirm is required in non-interactive mode');
+		}
+
+		// Confirm creation in interactive mode
+		if (!skipConfirm) {
+			const scope = projectId ? `project ${projectId}` : `organization ${orgId}`;
+			const confirmed = await tui.confirm(`Create API key "${opts.name}" for ${scope}?`);
+			if (!confirmed) {
+				tui.fatal('Operation cancelled');
+			}
+		}
+
+		let result: Awaited<ReturnType<typeof apikeyCreate>>;
+		try {
+			result = await tui.spinner('Creating API key', () => {
+				return apikeyCreate(apiClient, {
+					name: opts.name,
+					expiresAt: expiresAt,
+					projectId: projectId,
+					orgId: orgId,
+				});
+			});
+		} catch (error) {
+			if (error instanceof Error) {
+				tui.fatal(error.message);
+			}
+			throw error;
+		}
+
+		if (!options.json) {
+			tui.newline();
+			tui.success('API key created successfully!');
+			tui.newline();
+			tui.warn('Make sure to copy the API key value now. You will not be able to see it again.');
+			tui.newline();
+
+			const rows = [
+				{
+					ID: result.id,
+					Name: opts.name,
+					Value: result.value,
+					'Expires At': expiresAt,
+				},
+			];
+
+			tui.table(rows);
+		}
+
+		return result;
+	},
+});

package/src/cmd/cloud/apikey/delete.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { apikeyDelete } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+const APIKeyDeleteResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	id: z.string().describe('API key id that was deleted'),
+});
+
+export const deleteSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['del', 'rm'],
+	description: 'Delete an API key (soft delete)',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	idempotent: true,
+	examples: [
+		getCommand('cloud apikey delete <id>'),
+		getCommand('cloud apikey del <id>'),
+		getCommand('cloud apikey rm <id>'),
+	],
+	requires: { auth: true, apiClient: true },
+	schema: {
+		args: z.object({
+			id: z.string().describe('the API key id to delete'),
+		}),
+		response: APIKeyDeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, apiClient, options } = ctx;
+
+		let rowsAffected: Awaited<ReturnType<typeof apikeyDelete>>;
+		try {
+			rowsAffected = await tui.spinner('Deleting API key', () => {
+				return apikeyDelete(apiClient, args.id);
+			});
+		} catch (error) {
+			if (error instanceof Error && error.message.includes('not found')) {
+				tui.fatal(
+					`API key '${args.id}' not found or is not a custom key`,
+					ErrorCode.RESOURCE_NOT_FOUND
+				);
+			}
+			throw error;
+		}
+
+		if (rowsAffected === 0) {
+			tui.fatal(
+				`API key '${args.id}' not found or is not a custom key`,
+				ErrorCode.RESOURCE_NOT_FOUND
+			);
+		}
+
+		if (!options.json) {
+			tui.success(`API key '${args.id}' deleted successfully`);
+		}
+
+		return {
+			success: true,
+			id: args.id,
+		};
+	},
+});

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { apikeyGet } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Get a specific API key by id',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [getCommand('cloud apikey get <id>')],
+	requires: { auth: true, apiClient: true },
+	idempotent: true,
+	schema: {
+		args: z.object({
+			id: z.string().describe('the API key id'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, apiClient, options } = ctx;
+
+		let apiKey: Awaited<ReturnType<typeof apikeyGet>>;
+		try {
+			apiKey = await tui.spinner('Fetching API key', () => {
+				return apikeyGet(apiClient, args.id);
+			});
+		} catch (error) {
+			if (error instanceof Error && error.message.includes('not found')) {
+				tui.fatal(`API key '${args.id}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
+			}
+			throw error;
+		}
+
+		if (!options.json) {
+			if (process.stdout.isTTY) {
+				tui.newline();
+				tui.success('API Key Details:');
+				tui.newline();
+			}
+
+			const rows = [
+				{
+					ID: apiKey.id,
+					Name: apiKey.name,
+					Type: apiKey.type,
+					'Organization ID': apiKey.orgId,
+					Project: apiKey.project?.name ?? '-',
+					'Project ID': apiKey.project?.id ?? '-',
+					'Last Used': apiKey.lastUsedAt || 'Never',
+					'Expires At': apiKey.expiresAt ?? 'Never',
+					'Created At': apiKey.createdAt,
+				},
+			];
+
+			tui.table(rows);
+		}
+
+		return apiKey;
+	},
+});

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

@@ -0,0 +1,13 @@
+import { createCommand } from '../../../types';
+import { createSubcommand } from './create';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+import { deleteSubcommand } from './delete';
+
+export const command = createCommand({
+	name: 'apikey',
+	description: 'Manage API keys',
+	tags: ['fast', 'requires-auth'],
+	subcommands: [createSubcommand, listSubcommand, getSubcommand, deleteSubcommand],
+});
+export default command;

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

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { apikeyList } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List all API keys',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [getCommand('cloud apikey list'), getCommand('cloud apikey ls')],
+	requires: { auth: true, apiClient: true },
+	idempotent: true,
+	schema: {
+		options: z.object({
+			orgId: z.string().optional().describe('filter by organization id'),
+			projectId: z.string().optional().describe('filter by project id'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { opts, apiClient, options } = ctx;
+
+		const apiKeys = await tui.spinner('Fetching API keys', () => {
+			return apikeyList(apiClient, {
+				orgId: opts?.orgId,
+				projectId: opts?.projectId,
+			});
+		});
+
+		if (!options.json) {
+			if (apiKeys.length === 0) {
+				tui.info('No API keys found');
+			} else {
+				if (process.stdout.isTTY) {
+					tui.newline();
+					tui.success(`API Keys (${apiKeys.length}):`);
+					tui.newline();
+				}
+
+				const rows = apiKeys.map((key) => ({
+					ID: key.id,
+					Name: key.name,
+					Type: key.type,
+					Project: key.project?.name ?? '-',
+					'Last Used': key.lastUsedAt || 'Never',
+					'Expires At': key.expiresAt ?? 'Never',
+					'Created At': key.createdAt,
+				}));
+
+				tui.table(rows);
+			}
+		}
+
+		return apiKeys;
+	},
+});

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

@@ -1,5 +1,6 @@
 import { createCommand } from '../../../types';
 import { listSubcommand } from './list';
+import { logsSubcommand } from './logs';
 import { showSubcommand } from './show';
 import { removeSubcommand } from './remove';
 import { rollbackSubcommand } from './rollback';
@@ -12,6 +13,7 @@ export const deploymentCommand = createCommand({
 	aliases: ['deployments', 'dep'],
 	subcommands: [
 		listSubcommand,
+		logsSubcommand,
 		showSubcommand,
 		removeSubcommand,
 		rollbackSubcommand,

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

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectDeploymentLogs, DeploymentLogSchema } from '@agentuity/server';
+import { resolveProjectId } from './utils';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+export const logsSubcommand = createSubcommand({
+	name: 'logs',
+	aliases: ['log'],
+	description: 'View logs for a specific deployment',
+	tags: ['read-only', 'fast', 'requires-auth', 'requires-deployment'],
+	examples: [
+		`${getCommand('cloud deployment logs')} deploy_abc123xyz`,
+		`${getCommand('cloud deployment logs')} deploy_abc123xyz --limit=50`,
+		`${getCommand('cloud deployment logs')} deploy_abc123xyz --no-timestamps  # hide timestamps`,
+		`${getCommand('cloud deployment logs')} deploy_abc123xyz --project-id=proj_abc123xyz`,
+	],
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
+	prerequisites: ['cloud deploy'],
+	schema: {
+		args: z.object({
+			deployment_id: z.string().describe('Deployment ID'),
+		}),
+		options: z.object({
+			projectId: z.string().optional().describe('Project ID'),
+			limit: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.default(100)
+				.describe('Maximum number of logs to return'),
+			timestamps: z.boolean().default(true).describe('Show timestamps in output'),
+		}),
+		response: z.array(DeploymentLogSchema),
+	},
+	idempotent: true,
+	async handler(ctx) {
+		const { apiClient, args, options } = ctx;
+		const limit = ctx.opts.limit;
+		const showTimestamps = ctx.opts.timestamps;
+
+		try {
+			const projectId = resolveProjectId(ctx, { projectId: ctx.opts.projectId });
+			const logs = await projectDeploymentLogs(apiClient, projectId, args.deployment_id, limit);
+
+			if (!options.json) {
+				if (logs.length === 0) {
+					tui.info('No logs found for this deployment');
+				} else {
+					for (const log of logs) {
+						const severityColor = tui.getSeverityColor(log.severity);
+						if (showTimestamps) {
+							const timestamp = new Date(log.timestamp).toLocaleString();
+							console.log(
+								`${tui.muted(timestamp)} ${severityColor(log.severity.padEnd(5))} ${log.body}`
+							);
+						} else {
+							console.log(`${severityColor(log.severity.padEnd(5))} ${log.body}`);
+						}
+					}
+				}
+			}
+
+			return logs;
+		} catch (ex) {
+			tui.fatal(
+				`Failed to fetch deployment logs: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});

package/src/cmd/cloud/index.ts

@@ -6,19 +6,25 @@ import { sshSubcommand } from './ssh';
 import { scpSubcommand } from './scp';
 import { deploymentCommand } from './deployment';
 import keyvalueCommand from './keyvalue';
-import agentsCommand from './agents';
+import { agentCommand } from './agent';
 import objectstoreCommand from './objectstore';
 import envCommand from './env';
 import secretCommand from './secret';
+import apikeyCommand from './apikey';
+import streamCommand from './stream';
+import vectorCommand from './vector';
 
 export const command = createCommand({
 	name: 'cloud',
 	description: 'Cloud related commands',
 	tags: ['slow', 'requires-auth'],
 	subcommands: [
+		apikeyCommand,
 		keyvalueCommand,
-		agentsCommand,
+		agentCommand,
 		objectstoreCommand,
+		streamCommand,
+		vectorCommand,
 		envCommand,
 		secretCommand,
 		deploySubcommand,

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
-import { sessionGet, type SpanNode } from '@agentuity/server';
+import { sessionGet, type SpanNode, type EvalRun, type AgentInfo } from '@agentuity/server';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 import { getCatalystAPIClient } from '../../../config';
@@ -95,7 +95,7 @@ function printTimeline(node: SpanNode, prefix: string, isLast = true): void {
 
 	const childPrefix = prefix + (isLast ? '    ' : '│   ');
 	const children = node.children ?? [];
-	children.forEach((child, index) => {
+	children.forEach((child: SpanNode, index: number) => {
 		printTimeline(child, childPrefix, index === children.length - 1);
 	});
 }
@@ -142,7 +142,7 @@ export const getSubcommand = createSubcommand({
 				route_id: session.route_id,
 				thread_id: session.thread_id,
 				agents: enriched.agents,
-				eval_runs: enriched.evalRuns.map((run) => ({
+				eval_runs: enriched.evalRuns.map((run: EvalRun) => ({
 					id: run.id,
 					eval_id: run.eval_id,
 					created_at: run.created_at,
@@ -189,7 +189,7 @@ export const getSubcommand = createSubcommand({
 			}
 			if (enriched.agents.length > 0) {
 				const agentDisplay = enriched.agents
-					.map((agent) => `${agent.name} ${tui.muted(`(${agent.identifier})`)}`)
+					.map((agent: AgentInfo) => `${agent.name} ${tui.muted(`(${agent.identifier})`)}`)
 					.join(', ');
 				console.log(tui.bold('Agents:      ') + agentDisplay);
 			}
@@ -206,7 +206,7 @@ export const getSubcommand = createSubcommand({
 			if (enriched.evalRuns.length > 0) {
 				console.log('');
 				console.log(tui.bold('Eval Runs:'));
-				const evalTableData = enriched.evalRuns.map((run) => ({
+				const evalTableData = enriched.evalRuns.map((run: EvalRun) => ({
 					ID: run.id,
 					'Eval ID': run.eval_id,
 					Success: run.success ? tui.colorSuccess('✓') : tui.colorError('✗'),

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

@@ -15,9 +15,13 @@ const SessionLogsResponseSchema = z.array(
 
 export const logsSubcommand = createSubcommand({
 	name: 'logs',
+	aliases: ['log'],
 	description: 'Get logs for a specific session',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	examples: [`${getCommand('cloud session logs')} sess_abc123xyz`],
+	examples: [
+		`${getCommand('cloud session logs')} sess_abc123xyz`,
+		`${getCommand('cloud session logs')} --no-timestamps  # hide timestamps`,
+	],
 	requires: { auth: true, apiClient: true },
 	optional: { project: true },
 	idempotent: true,
@@ -28,11 +32,13 @@ export const logsSubcommand = createSubcommand({
 		options: z.object({
 			projectId: z.string().optional().describe('Project ID (for display purposes)'),
 			deploymentId: z.string().optional().describe('Deployment ID (for display purposes)'),
+			timestamps: z.boolean().default(true).describe('Show timestamps in output'),
 		}),
 		response: SessionLogsResponseSchema,
 	},
 	async handler(ctx) {
 		const { apiClient, args, options } = ctx;
+		const showTimestamps = ctx.opts.timestamps ?? true;
 
 		try {
 			const logs = await sessionLogs(apiClient, { id: args.session_id });
@@ -41,19 +47,14 @@ export const logsSubcommand = createSubcommand({
 				if (logs.length === 0) {
 					tui.info('No logs found for this session.');
 				} else {
-					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 timestamp = showTimestamps
+							? `${tui.muted(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);
+						const severityColor = tui.getSeverityColor(log.severity)(severity);
 
-						console.log(`${tui.muted(timestamp)} ${severityColor} ${log.body}`);
+						console.log(`${timestamp}${severityColor} ${log.body}`);
 					}
 				}
 			}