@agentuity/cli 0.0.48 → 0.0.50

package/src/cli-logger.ts

@@ -0,0 +1,80 @@
+import type { Logger, GlobalOptions } from './types';
+import { exitWithError, type StructuredError, ErrorCode, createError, getExitCode } from './errors';
+
+/**
+ * Enhanced logger wrapper that supports structured errors
+ */
+export class CLILogger implements Logger {
+	constructor(
+		private logger: Logger,
+		private options: GlobalOptions
+	) {}
+
+	/**
+	 * Exit with a structured error (supports --error-format=json)
+	 */
+	fatalWithError(error: StructuredError): never {
+		const errorFormat = this.options.errorFormat ?? 'text';
+		return exitWithError(error, this.logger, errorFormat);
+	}
+
+	// Delegate all other logger methods
+	trace(message: string, ...args: unknown[]): void {
+		this.logger.trace(message, ...args);
+	}
+
+	debug(message: string, ...args: unknown[]): void {
+		this.logger.debug(message, ...args);
+	}
+
+	info(message: string, ...args: unknown[]): void {
+		this.logger.info(message, ...args);
+	}
+
+	warn(message: string, ...args: unknown[]): void {
+		this.logger.warn(message, ...args);
+	}
+
+	error(message: string, ...args: unknown[]): void {
+		this.logger.error(message, ...args);
+	}
+
+	fatal(message: string, errorCode?: ErrorCode, ...args: unknown[]): never {
+		if (errorCode) {
+			// Use structured error with proper exit code
+			const formattedMessage = args.length > 0 ? this.formatMessage(message, ...args) : message;
+			const error = createError(errorCode, formattedMessage);
+			const exitCode = getExitCode(errorCode);
+
+			if (this.options.errorFormat === 'json') {
+				exitWithError(error, this.logger, 'json');
+			} else {
+				this.logger.error(formattedMessage);
+				process.exit(exitCode);
+			}
+		} else {
+			// Fallback to default behavior (exit code 1)
+			this.logger.fatal(message, ...args);
+		}
+	}
+
+	private formatMessage(message: string, ...args: unknown[]): string {
+		// Simple sprintf-style formatting
+		let formatted = message;
+		for (const arg of args) {
+			formatted = formatted.replace(/%[sd]/, String(arg));
+		}
+		return formatted;
+	}
+
+	child(opts: Record<string, unknown>): Logger {
+		return this.logger.child(opts);
+	}
+}
+
+/**
+ * Wrap a logger with CLI error handling capabilities
+ */
+export function wrapLogger(logger: Logger, options: GlobalOptions): CLILogger {
+	return new CLILogger(logger, options);
+}

package/src/cli.ts

@@ -9,6 +9,7 @@ import type {
 	Optional,
 	Logger,
 	AuthData,
+	GlobalOptions,
 } from './types';
 import { showBanner } from './banner';
 import { requireAuth, optionalAuth, requireOrg, optionalOrg as selectOptionalOrg } from './auth';
@@ -18,6 +19,9 @@ import * as tui from './tui';
 import { parseArgsSchema, parseOptionsSchema, buildValidationInput } from './schema-parser';
 import { defaultProfileName, loadProjectConfig } from './config';
 import { APIClient, getAPIBaseURL, type APIClient as APIClientType } from './api';
+import { ErrorCode, ExitCode, createError, exitWithError } from './errors';
+import { getCommand } from './command-prefix';
+import { isValidateMode, outputValidation, type ValidationResult } from './output';
 
 function createAPIClient(baseCtx: CommandContext, config: Config | null): APIClient {
 	try {
@@ -41,6 +45,71 @@ function createAPIClient(baseCtx: CommandContext, config: Config | null): APICli
 	}
 }
 
+/**
+ * Execute handler or output validation result based on mode
+ */
+async function executeOrValidate(
+	ctx: CommandContext,
+	commandName: string,
+	handler?: (ctx: CommandContext) => unknown | Promise<unknown>
+): Promise<void> {
+	if (isValidateMode(ctx.options)) {
+		// In validate mode, just output success (validation already passed via Zod)
+		const result: ValidationResult = {
+			valid: true,
+			command: commandName,
+		};
+		outputValidation(result, ctx.options);
+	} else if (handler) {
+		// Normal execution
+		await handler(ctx);
+	}
+}
+
+/**
+ * Handle validation error - output structured result in validate mode, otherwise log and exit
+ */
+function handleValidationError(
+	error: unknown,
+	commandName: string,
+	baseCtx: { options: GlobalOptions; logger: Logger }
+): never {
+	if (error && typeof error === 'object' && 'issues' in error) {
+		const issues = (error as { issues: Array<{ path: string[]; message: string }> }).issues;
+
+		if (isValidateMode(baseCtx.options)) {
+			// In validate mode, output structured validation result
+			const result: ValidationResult = {
+				valid: false,
+				command: commandName,
+				errors: issues.map((issue) => ({
+					field: issue.path?.length ? issue.path.join('.') : 'unknown',
+					message: issue.message,
+				})),
+			};
+			outputValidation(result, baseCtx.options);
+			process.exit(ExitCode.VALIDATION_ERROR);
+		} else {
+			// Use centralized error handling
+			exitWithError(
+				{
+					code: ErrorCode.VALIDATION_FAILED,
+					message: 'Validation error',
+					details: {
+						issues: issues.map((issue) => ({
+							field: issue.path?.length ? issue.path.join('.') : 'unknown',
+							message: issue.message,
+						})),
+					},
+				},
+				baseCtx.logger,
+				baseCtx.options.errorFormat ?? 'text'
+			);
+		}
+	}
+	throw error;
+}
+
 type Normalized = {
 	requiresAuth: boolean;
 	optionalAuth: false | string;
@@ -97,7 +166,12 @@ function normalizeReqs(def: CommandDefinition | SubcommandDefinition): Normalize
 	};
 }
 
-function handleProjectConfigError(error: unknown, requiresProject: boolean, logger: Logger): never {
+function handleProjectConfigError(
+	error: unknown,
+	requiresProject: boolean,
+	logger: Logger,
+	errorFormat?: 'json' | 'text'
+): never {
 	if (
 		requiresProject &&
 		error &&
@@ -105,8 +179,14 @@ function handleProjectConfigError(error: unknown, requiresProject: boolean, logg
 		'name' in error &&
 		error.name === 'ProjectConfigNotFoundExpection'
 	) {
-		logger.fatal(
-			'invalid project folder. use --dir to specify a different directory or change to a project folder'
+		exitWithError(
+			createError(ErrorCode.PROJECT_NOT_FOUND, 'Invalid project folder', undefined, [
+				'Use --dir to specify a different directory',
+				'Change to a directory containing agentuity.json',
+				`Run "${getCommand('project init')}" to create a new project`,
+			]),
+			logger,
+			errorFormat ?? 'text'
 		);
 	}
 	throw error;
@@ -117,11 +197,11 @@ export async function createCLI(version: string): Promise<Command> {
 
 	program
 		.name('agentuity')
-		.description('Agentuity CLI')
 		.version(version, '-V, --version', 'Display version')
-		.helpOption('-h, --help', 'Display help')
+		.helpOption('-h, --help=[json]', 'Display help (with optional JSON output)')
 		.allowUnknownOption(false)
-		.allowExcessArguments(false);
+		.allowExcessArguments(false)
+		.showHelpAfterError(true);
 
 	program
 		.option('--config <path>', 'Config file path')
@@ -133,7 +213,15 @@ export async function createCLI(version: string): Promise<Command> {
 			'Use a specific organization when performing operations',
 			process.env.AGENTUITY_CLOUD_ORG_ID
 		)
-		.option('--color-scheme <scheme>', 'Color scheme: light or dark');
+		.option('--color-scheme <scheme>', 'Color scheme: light or dark')
+		.option('--color <mode>', 'Color output: auto, always, never', 'auto')
+		.option('--error-format <format>', 'Error output format: json or text', 'text')
+		.option('--json', 'Output in JSON format (machine-readable)', false)
+		.option('--quiet', 'Suppress non-essential output', false)
+		.option('--no-progress', 'Disable progress indicators', false)
+		.option('--explain', 'Show what the command would do without executing', false)
+		.option('--dry-run', 'Execute command without making changes', false)
+		.option('--validate', 'Validate arguments and options without executing', false);
 
 	const skipVersionCheckOption = program.createOption(
 		'--skip-version-check',
@@ -160,7 +248,7 @@ export async function createCLI(version: string): Promise<Command> {
 			});
 		}
 		console.error();
-		console.error(`Run 'agentuity --help' for usage information.`);
+		console.error(`Run '${getCommand('--help')}' for usage information.`);
 		process.exit(1);
 	});
 
@@ -173,7 +261,7 @@ export async function createCLI(version: string): Promise<Command> {
 				const match = str.match(/got (\d+)/);
 				if (match) {
 					write(`error: unknown command or subcommand\n`);
-					write(`\nRun 'agentuity --help' for available commands.\n`);
+					write(`\nRun '${getCommand('--help')}' for available commands.\n`);
 				} else {
 					write(str);
 				}
@@ -219,7 +307,17 @@ async function resolveRegion(opts: ResolveRegionOptions): Promise<string | undef
 	// No regions available
 	if (regions.length === 0) {
 		if (required) {
-			logger.fatal('No cloud regions available');
+			const errorFormat = (options as Record<string, unknown>).errorFormat as
+				| 'json'
+				| 'text'
+				| undefined;
+			exitWithError(
+				createError(ErrorCode.NO_REGIONS_AVAILABLE, 'No cloud regions available', undefined, [
+					'Contact support if you need access to cloud regions',
+				]),
+				logger,
+				errorFormat ?? 'text'
+			);
 		}
 		return undefined;
 	}
@@ -231,8 +329,19 @@ async function resolveRegion(opts: ResolveRegionOptions): Promise<string | undef
 	if (region) {
 		const found = regions.find((r) => r.region === region);
 		if (!found) {
-			logger.fatal(
-				`Invalid region '${region}'. Use one of: ${regions.map((r) => r.region).join(', ')}`
+			const errorFormat = (options as Record<string, unknown>).errorFormat as
+				| 'json'
+				| 'text'
+				| undefined;
+			exitWithError(
+				createError(
+					ErrorCode.REGION_NOT_FOUND,
+					`Invalid region '${region}'`,
+					{ region, availableRegions: regions.map((r) => r.region) },
+					[`Use one of: ${regions.map((r) => r.region).join(', ')}`]
+				),
+				logger,
+				errorFormat ?? 'text'
 			);
 		}
 		return region;
@@ -249,7 +358,20 @@ async function resolveRegion(opts: ResolveRegionOptions): Promise<string | undef
 
 	// No flag provided - handle TTY vs non-TTY
 	if (required && !process.stdin.isTTY) {
-		logger.fatal('--region flag is required in non-interactive mode');
+		const errorFormat = (options as Record<string, unknown>).errorFormat as
+			| 'json'
+			| 'text'
+			| undefined;
+		exitWithError(
+			createError(
+				ErrorCode.REGION_REQUIRED,
+				'--region flag is required in non-interactive mode',
+				{ availableRegions: regions.map((r) => r.region) },
+				[`Use --region with one of: ${regions.map((r) => r.region).join(', ')}`]
+			),
+			logger,
+			errorFormat ?? 'text'
+		);
 	}
 
 	if (process.stdin.isTTY) {
@@ -274,6 +396,13 @@ async function registerSubcommand(
 		cmd.aliases(subcommand.aliases);
 	}
 
+	// Add examples to help text
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const examples = (subcommand as any).examples as string[] | undefined;
+	if (examples && examples.length > 0) {
+		cmd.addHelpText('after', '\nExamples:\n' + examples.map((ex) => `  ${ex}`).join('\n'));
+	}
+
 	// Check if this subcommand has its own subcommands (nested subcommands)
 	const subDef = subcommand as unknown as { subcommands?: SubcommandDefinition[] };
 	if (subDef.subcommands && subDef.subcommands.length > 0) {
@@ -323,19 +452,21 @@ async function registerSubcommand(
 		for (const opt of parsed) {
 			const flag = opt.name.replace(/([A-Z])/g, '-$1').toLowerCase();
 			const desc = opt.description || '';
+			// Add short flag alias for verbose
+			const flagSpec = flag === 'verbose' ? `-v, --${flag}` : `--${flag}`;
 			if (opt.type === 'boolean') {
 				if (opt.hasDefault) {
 					const defaultValue =
 						typeof opt.defaultValue === 'function' ? opt.defaultValue() : opt.defaultValue;
 					cmd.option(`--no-${flag}`, desc);
-					cmd.option(`--${flag}`, desc, defaultValue);
+					cmd.option(flagSpec, desc, defaultValue);
 				} else {
-					cmd.option(`--${flag}`, desc);
+					cmd.option(flagSpec, desc);
 				}
 			} else if (opt.type === 'number') {
-				cmd.option(`--${flag} <${opt.name}>`, desc, parseFloat);
+				cmd.option(`${flagSpec} <${opt.name}>`, desc, parseFloat);
 			} else {
-				cmd.option(`--${flag} <${opt.name}>`, desc);
+				cmd.option(`${flagSpec} <${opt.name}>`, desc);
 			}
 		}
 	}
@@ -368,8 +499,14 @@ async function registerSubcommand(
 						'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'
+						exitWithError(
+							createError(ErrorCode.PROJECT_NOT_FOUND, 'Invalid project folder', undefined, [
+								'Use --dir to specify a different directory',
+								'Change to a directory containing agentuity.json',
+								`Run "${getCommand('project init')}" to create a new project`,
+							]),
+							baseCtx.logger,
+							baseCtx.options.errorFormat
 						);
 					}
 					throw error;
@@ -448,22 +585,21 @@ async function registerSubcommand(
 							ctx.region = region;
 						}
 					}
-					if (subcommand.handler) {
-						await subcommand.handler(ctx as CommandContext);
-					}
+					await executeOrValidate(
+						ctx as CommandContext,
+						`${parent.name()} ${subcommand.name}`,
+						subcommand.handler
+					);
 				} catch (error) {
 					if (error && typeof error === 'object' && 'issues' in error) {
-						baseCtx.logger.error('Validation error:');
-						const issues = (error as { issues: Array<{ path: string[]; message: string }> })
-							.issues;
-						for (const issue of issues) {
-							baseCtx.logger.error(
-								`  ${issue.path?.length ? issue.path.join('.') + ': ' : ''}${issue.message}`
-							);
-						}
-						process.exit(1);
+						handleValidationError(error, `${parent.name()} ${subcommand.name}`, baseCtx);
 					}
-					handleProjectConfigError(error, normalized.requiresProject, baseCtx.logger);
+					handleProjectConfigError(
+						error,
+						normalized.requiresProject,
+						baseCtx.logger,
+						baseCtx.options.errorFormat
+					);
 				}
 			} else {
 				const ctx: Record<string, unknown> = {
@@ -596,22 +732,21 @@ async function registerSubcommand(
 							ctx.region = region;
 						}
 					}
-					if (subcommand.handler) {
-						await subcommand.handler(ctx as CommandContext);
-					}
+					await executeOrValidate(
+						ctx as CommandContext,
+						`${parent.name()} ${subcommand.name}`,
+						subcommand.handler
+					);
 				} catch (error) {
 					if (error && typeof error === 'object' && 'issues' in error) {
-						baseCtx.logger.error('Validation error:');
-						const issues = (error as { issues: Array<{ path: string[]; message: string }> })
-							.issues;
-						for (const issue of issues) {
-							baseCtx.logger.error(
-								`  ${issue.path?.length ? issue.path.join('.') + ': ' : ''}${issue.message}`
-							);
-						}
-						process.exit(1);
+						handleValidationError(error, `${parent.name()} ${subcommand.name}`, baseCtx);
 					}
-					handleProjectConfigError(error, normalized.requiresProject, baseCtx.logger);
+					handleProjectConfigError(
+						error,
+						normalized.requiresProject,
+						baseCtx.logger,
+						baseCtx.options.errorFormat
+					);
 				}
 			} else {
 				const ctx: Record<string, unknown> = {
@@ -694,22 +829,21 @@ async function registerSubcommand(
 							ctx as CommandContext & { apiClient: APIClientType }
 						);
 					}
-					if (subcommand.handler) {
-						await subcommand.handler(ctx as CommandContext);
-					}
+					await executeOrValidate(
+						ctx as CommandContext,
+						`${parent.name()} ${subcommand.name}`,
+						subcommand.handler
+					);
 				} catch (error) {
 					if (error && typeof error === 'object' && 'issues' in error) {
-						baseCtx.logger.error('Validation error:');
-						const issues = (error as { issues: Array<{ path: string[]; message: string }> })
-							.issues;
-						for (const issue of issues) {
-							baseCtx.logger.error(
-								`  ${issue.path?.length ? issue.path.join('.') + ': ' : ''}${issue.message}`
-							);
-						}
-						process.exit(1);
+						handleValidationError(error, `${parent.name()} ${subcommand.name}`, baseCtx);
 					}
-					handleProjectConfigError(error, normalized.requiresProject, baseCtx.logger);
+					handleProjectConfigError(
+						error,
+						normalized.requiresProject,
+						baseCtx.logger,
+						baseCtx.options.errorFormat
+					);
 				}
 			} else {
 				const ctx: Record<string, unknown> = {

package/src/cmd/agents/index.ts

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import * as tui from '../../tui';
+import { APIResponseSchema } from '@agentuity/server';
+import { Table } from 'console-table-printer';
+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 command = createCommand({
+	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 {
+			const table = new Table({
+				columns: [
+					{ name: 'Name', alignment: 'left' },
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Identifier', alignment: 'left' },
+					{ name: 'Deployment', alignment: 'left' },
+					{ name: 'Version', alignment: 'left' },
+					{ name: 'Evals', alignment: 'center' },
+					{ name: 'Created', alignment: 'left' },
+				],
+			});
+
+			for (const agent of agents) {
+				table.addRow({
+					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,
+					Created: new Date(agent.createdAt).toLocaleString(),
+				});
+			}
+			table.printTable();
+
+			// 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({
+						columns: [
+							{ name: 'Name', alignment: 'left' },
+							{ name: 'ID', alignment: 'left' },
+							{ name: 'Identifier', alignment: 'left' },
+							{ name: 'Deployment', alignment: 'left' },
+							{ name: 'Version', alignment: 'left' },
+							{ name: 'Description', alignment: 'left' },
+							{ name: 'Created', alignment: 'left' },
+						],
+					});
+
+					for (const evalItem of agent.evals) {
+						evalTable.addRow({
+							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),
+							Created: new Date(evalItem.createdAt).toLocaleString(),
+						});
+					}
+					evalTable.printTable();
+				}
+			}
+		}
+	},
+});

package/src/cmd/auth/index.ts

@@ -8,5 +8,6 @@ import { sshSubcommand } from './ssh';
 export const command = createCommand({
 	name: 'auth',
 	description: 'Authentication and authorization related commands',
+	tags: ['read-only', 'fast'],
 	subcommands: [loginCommand, logoutCommand, signupCommand, whoamiCommand, sshSubcommand],
 });

package/src/cmd/auth/login.ts

@@ -4,12 +4,17 @@ import { getAppBaseURL } from '../../api';
 import { saveAuth } from '../../config';
 import { generateLoginOTP, pollForLoginCompletion } from './api';
 import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
 
 export const loginCommand = createSubcommand({
 	name: 'login',
 	description: 'Login to the Agentuity Platform using a browser-based authentication flow',
+	tags: ['mutating', 'creates-resource', 'slow', 'api-intensive'],
 	toplevel: true,
+	idempotent: false,
 	requires: { apiClient: true },
+	examples: [getCommand('auth login'), getCommand('login')],
 	async handler(ctx) {
 		const { logger, config, apiClient } = ctx;
 
@@ -78,9 +83,9 @@ export const loginCommand = createSubcommand({
 				error.issues.map((i) => tui.arrow(`${i.message} for ${i.path}`));
 				process.exit(1);
 			} else if (error instanceof Error) {
-				logger.fatal(`Login failed: ${error.message}`);
+				logger.fatal(`Login failed: ${error.message}`, ErrorCode.AUTH_FAILED);
 			} else {
-				logger.fatal('Login failed');
+				logger.fatal('Login failed', ErrorCode.AUTH_FAILED);
 			}
 		}
 	},

package/src/cmd/auth/logout.ts

@@ -1,11 +1,15 @@
 import { createSubcommand } from '../../types';
 import { clearAuth } from '../../config';
 import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
 
 export const logoutCommand = createSubcommand({
 	name: 'logout',
 	description: 'Logout of the Agentuity Cloud Platform',
+	tags: ['mutating', 'deletes-resource', 'fast', 'requires-auth'],
 	toplevel: true,
+	idempotent: false,
+	examples: [getCommand('auth logout'), getCommand('logout')],
 
 	async handler() {
 		await clearAuth();