@agentuity/cli 0.0.58 → 0.0.59

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/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}`);
 					}
 				}
 			}

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const DeleteStreamResponseSchema = z.object({
+	id: z.string().describe('Stream ID'),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['del', 'rm'],
+	description: 'Delete a stream by ID (soft delete)',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, project: true },
+	examples: [
+		`${getCommand('stream delete stream-id-123')} - Delete a stream`,
+		`${getCommand('stream rm stream-id-456')} - Delete stream (using alias)`,
+		`${getCommand('stream del stream-id-789')} - Delete stream (using alias)`,
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('the stream ID to delete'),
+		}),
+		response: DeleteStreamResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		await storage.delete(args.id);
+
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			tui.success(`deleted stream ${args.id} in ${durationMs.toFixed(1)}ms`);
+		}
+
+		return {
+			id: args.id,
+		};
+	},
+});
+
+export default deleteSubcommand;

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

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+function formatBytes(bytes: number): string {
+	if (bytes === 0) return '0 B';
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+	return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+
+const GetStreamResponseSchema = z.object({
+	id: z.string().describe('Stream ID'),
+	name: z.string().describe('Stream name'),
+	metadata: z.record(z.string(), z.string()).describe('Stream metadata'),
+	url: z.string().describe('Public URL'),
+	sizeBytes: z.number().describe('Size in bytes'),
+});
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get detailed information about a specific stream',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	requires: { auth: true, project: true },
+	idempotent: true,
+	examples: [
+		`${getCommand('stream get stream-id-123')} - Get stream details`,
+		`${getCommand('stream get stream-id-123 --json')} - Get stream as JSON`,
+		`${getCommand('stream get stream-id-123 --output stream.dat')} - Download stream to file`,
+		`${getCommand('stream get stream-id-123 -o stream.dat')} - Download stream (short flag)`,
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('the stream ID'),
+		}),
+		options: z.object({
+			output: z.string().optional().describe('download stream content to file'),
+		}),
+		response: GetStreamResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		// If --output is specified, download the stream content
+		if (opts.output) {
+			const readable = await storage.download(args.id);
+			const file = Bun.file(opts.output);
+			const writer = file.writer();
+
+			const reader = readable.getReader();
+			try {
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					writer.write(value);
+				}
+				await writer.end();
+				const durationMs = Date.now() - started;
+				const stats = await Bun.file(opts.output).stat();
+				tui.success(
+					`downloaded ${formatBytes(stats.size)} to ${opts.output} in ${durationMs.toFixed(1)}ms`
+				);
+
+				// Fetch stream metadata to populate the response
+				const stream = await storage.get(args.id);
+				return {
+					id: args.id,
+					name: stream.name ?? '',
+					metadata: stream.metadata ?? {},
+					url: stream.url ?? '',
+					sizeBytes: stats.size,
+				};
+			} finally {
+				reader.releaseLock();
+			}
+		}
+
+		// Otherwise, get metadata
+		const stream = await storage.get(args.id);
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			if (!stream) {
+				tui.fatal(`Failed to retrieve stream metadata for ${args.id}`);
+			}
+
+			const sizeBytes = stream.sizeBytes ?? 0;
+
+			console.log(`Name:     ${tui.bold(stream.name ?? 'unknown')}`);
+			console.log(`ID:       ${stream.id}`);
+			console.log(`Size:     ${formatBytes(sizeBytes)}`);
+			console.log(`URL:      ${tui.link(stream.url ?? 'unknown')}`);
+			if (stream.metadata && Object.keys(stream.metadata).length > 0) {
+				console.log(`Metadata:`);
+				for (const [key, value] of Object.entries(stream.metadata)) {
+					console.log(`  ${key}: ${value}`);
+				}
+			}
+			tui.success(`retrieved in ${durationMs.toFixed(1)}ms`);
+		}
+
+		return {
+			id: stream.id,
+			name: stream.name,
+			metadata: stream.metadata,
+			url: stream.url,
+			sizeBytes: stream.sizeBytes,
+		};
+	},
+});
+
+export default getSubcommand;

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

@@ -0,0 +1,14 @@
+import { createCommand } from '../../../types';
+import listSubcommand from './list';
+import getSubcommand from './get';
+import deleteSubcommand from './delete';
+
+export const streamCommand = createCommand({
+	name: 'stream',
+	aliases: ['streams'],
+	description: 'Manage streams',
+	tags: ['slow', 'requires-auth'],
+	subcommands: [listSubcommand, getSubcommand, deleteSubcommand],
+});
+
+export default streamCommand;