@agentuity/cli 3.0.0-alpha.4 → 3.0.0-alpha.7

package/src/cmd/cloud/eval-run/list.ts

@@ -1,160 +0,0 @@
-import { z } from 'zod';
-import { createSubcommand } from '../../../types';
-import * as tui from '../../../tui';
-import { getCommand } from '../../../command-prefix';
-import { ErrorCode } from '../../../errors';
-import { evalRunList } from '@agentuity/server';
-
-const EvalRunListResponseSchema = z.array(
-	z.object({
-		id: z.string().describe('Eval run ID'),
-		eval_id: z.string().describe('Eval ID'),
-		eval_name: z.string().nullable().describe('Eval name'),
-		agent_identifier: z.string().nullable().describe('Agent identifier'),
-		session_id: z.string().describe('Session ID'),
-		created_at: z.string().describe('Creation timestamp'),
-		pending: z.boolean().describe('Whether the eval run is pending'),
-		success: z.boolean().describe('Whether the eval run succeeded'),
-		error: z.string().nullable().describe('Error message if failed'),
-		reason: z.string().nullable().describe('Reason for the result'),
-	})
-);
-
-export const listSubcommand = createSubcommand({
-	name: 'list',
-	aliases: ['ls'],
-	description: 'List eval runs',
-	tags: ['read-only', 'fast', 'requires-auth'],
-	examples: [
-		{ command: getCommand('cloud eval-run list'), description: 'List 10 most recent eval runs' },
-		{
-			command: getCommand('cloud eval-run list --count=25'),
-			description: 'List 25 most recent eval runs',
-		},
-		{
-			command: getCommand('cloud eval-run list --eval-id=eval_*'),
-			description: 'Filter by eval',
-		},
-		{
-			command: getCommand('cloud eval-run list --session-id=sess_*'),
-			description: 'Filter by session',
-		},
-		{
-			command: getCommand('cloud eval-run list --project-id=proj_*'),
-			description: 'Filter by project',
-		},
-		{
-			command: getCommand('cloud eval-run list --agent-id=agent_*'),
-			description: 'Filter by agent',
-		},
-		{
-			command: getCommand('cloud eval-run list --all'),
-			description: 'List all eval runs regardless of project context',
-		},
-	],
-	requires: { auth: true, apiClient: true },
-	optional: { project: true },
-	idempotent: true,
-	pagination: {
-		supported: true,
-		defaultLimit: 10,
-		maxLimit: 100,
-		parameters: {
-			limit: 'count',
-		},
-	},
-	schema: {
-		options: z.object({
-			orgId: z.string().optional().describe('filter by organization id'),
-			count: z.coerce
-				.number()
-				.int()
-				.min(1)
-				.max(100)
-				.default(10)
-				.describe('Number of eval runs to list (1–100)'),
-			projectId: z.string().optional().describe('Filter by project ID'),
-			all: z.boolean().optional().describe('List all eval runs regardless of project context'),
-			evalId: z.string().optional().describe('Filter by eval ID'),
-			agentId: z.string().optional().describe('Filter by agent ID'),
-			sessionId: z.string().optional().describe('Filter by session ID'),
-		}),
-		response: EvalRunListResponseSchema,
-	},
-	webUrl: (ctx) => {
-		const projectId = ctx.opts?.all ? undefined : ctx.opts?.projectId || ctx.project?.projectId;
-		return projectId ? `/projects/${encodeURIComponent(projectId)}/eval-runs` : undefined;
-	},
-	async handler(ctx) {
-		const { apiClient, project, opts, options } = ctx;
-
-		if (opts?.orgId && opts?.projectId) {
-			tui.fatal('--org-id and --project-id are mutually exclusive. Use one or the other.');
-		}
-
-		const projectId = opts.all || opts.orgId ? undefined : opts.projectId || project?.projectId;
-
-		try {
-			const evalRuns = await evalRunList(apiClient, {
-				orgId: opts?.orgId,
-				projectId,
-				evalId: opts.evalId,
-				sessionId: opts.sessionId,
-				agentId: opts.agentId,
-			});
-
-			const result = evalRuns.map((r) => ({
-				id: r.id,
-				eval_id: r.evalId,
-				eval_name: r.evalName,
-				agent_identifier: r.agentIdentifier,
-				session_id: r.sessionId,
-				created_at: r.createdAt,
-				pending: r.pending,
-				success: r.success,
-				error: r.error,
-				reason: r.result?.reason ?? null,
-			}));
-
-			if (options.json) {
-				return result;
-			}
-
-			if (evalRuns.length === 0) {
-				tui.info('No eval runs found.');
-				return [];
-			}
-
-			const tableData = evalRuns.map((r) => {
-				const reason = r.result?.reason;
-				return {
-					ID: r.id,
-					'Eval Name': r.evalName || '-',
-					Agent: r.agentIdentifier || '-',
-					Success: r.success ? '✓' : '✗',
-					Pending: r.pending ? '⏳' : '✓',
-					Reason: reason
-						? reason.length > 30
-							? reason.substring(0, 27) + '...'
-							: reason
-						: '-',
-					Created: new Date(r.createdAt).toLocaleString(),
-				};
-			});
-
-			tui.table(tableData, [
-				{ name: 'ID', alignment: 'left' },
-				{ name: 'Eval Name', alignment: 'left' },
-				{ name: 'Agent', alignment: 'left' },
-				{ name: 'Success', alignment: 'center' },
-				{ name: 'Pending', alignment: 'center' },
-				{ name: 'Reason', alignment: 'left' },
-				{ name: 'Created', alignment: 'left' },
-			]);
-
-			return result;
-		} catch (ex) {
-			tui.fatal(`Failed to list eval runs: ${ex}`, ErrorCode.API_ERROR);
-		}
-	},
-});

package/src/cmd/project/auth/generate.ts

@@ -1,116 +0,0 @@
-/**
- * Generate auth schema SQL using drizzle-kit export
- */
-
-import { z } from 'zod';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { createSubcommand } from '../../../types';
-import * as tui from '../../../tui';
-import { getCommand } from '../../../command-prefix';
-import { generateAuthSchemaSql, getGeneratedSqlDir } from './shared';
-
-export const generateSubcommand = createSubcommand({
-	name: 'generate',
-	description: 'Generate SQL schema for Agentuity Auth tables',
-	tags: ['slow'],
-	requires: { project: true },
-	examples: [
-		{
-			command: getCommand('project auth generate'),
-			description: 'Generate SQL schema and save to agentuity-auth-schema.sql',
-		},
-		{
-			command: getCommand('project auth generate --output ./migrations/auth.sql'),
-			description: 'Generate schema to a custom path',
-		},
-		{
-			command: getCommand('project auth generate --output -'),
-			description: 'Output SQL to stdout',
-		},
-	],
-	schema: {
-		options: z.object({
-			output: z
-				.string()
-				.optional()
-				.describe(
-					'Output path for generated SQL (default: ./agentuity-auth-schema.sql). Use "-" for stdout.'
-				),
-		}),
-		response: z.object({
-			success: z.boolean().describe('Whether generation succeeded'),
-			outputPath: z.string().optional().describe('Path where SQL was written'),
-		}),
-	},
-
-	async handler(ctx) {
-		const { logger, opts, projectDir, options } = ctx;
-		const explicitOutput = opts?.output as string | undefined;
-		const toStdout = explicitOutput === '-';
-		const isJson = options?.json === true;
-
-		if (!toStdout && !isJson) {
-			tui.newline();
-			tui.info(tui.bold('Agentuity Auth Schema Generation'));
-			tui.newline();
-		}
-
-		try {
-			const sql = isJson
-				? await generateAuthSchemaSql(logger, projectDir)
-				: await tui.spinner({
-						message: 'Generating auth schema SQL from Drizzle schema',
-						clearOnSuccess: true,
-						callback: () => generateAuthSchemaSql(logger, projectDir),
-					});
-
-			if (toStdout) {
-				console.log(sql);
-				return { success: true };
-			}
-
-			let outputPath: string;
-			let displayPath: string;
-
-			if (explicitOutput) {
-				outputPath = path.resolve(projectDir, explicitOutput);
-				displayPath = explicitOutput;
-			} else {
-				const sqlOutputDir = await getGeneratedSqlDir(projectDir);
-				const sqlFileName = 'agentuity-auth-schema.sql';
-				outputPath = path.join(sqlOutputDir, sqlFileName);
-				displayPath =
-					sqlOutputDir === projectDir ? sqlFileName : path.relative(projectDir, outputPath);
-			}
-
-			fs.writeFileSync(outputPath, sql);
-
-			if (!isJson) {
-				tui.success(`Auth schema SQL saved to ${tui.bold(displayPath)}`);
-				tui.newline();
-				tui.info('Next steps:');
-				console.log('  1. Review the generated SQL file');
-				console.log('  2. Run the SQL against your database');
-				console.log(`     ${tui.muted('Or use: agentuity project auth init')}`);
-				tui.newline();
-			}
-
-			return { success: true, outputPath };
-		} catch (error) {
-			logger.error('Schema generation failed', { error });
-
-			if (!isJson) {
-				tui.error(
-					`Schema generation failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-				);
-				tui.newline();
-				tui.info('Make sure you have:');
-				console.log('  1. @agentuity/auth installed as a dependency');
-				console.log('  2. drizzle-kit available (installed with @agentuity/auth)');
-			}
-
-			return { success: false };
-		}
-	},
-});

package/src/cmd/project/auth/index.ts

@@ -1,21 +0,0 @@
-import { createCommand } from '../../../types';
-import { initSubcommand } from './init';
-import { generateSubcommand } from './generate';
-import { getCommand } from '../../../command-prefix';
-
-export const authCommand = createCommand({
-	name: 'auth',
-	description: 'Manage project authentication (Agentuity Auth)',
-	tags: ['slow', 'requires-auth'],
-	examples: [
-		{
-			command: getCommand('project auth init'),
-			description: 'Set up Agentuity Auth for an existing project',
-		},
-		{
-			command: getCommand('project auth generate'),
-			description: 'Generate SQL schema for auth tables',
-		},
-	],
-	subcommands: [initSubcommand, generateSubcommand],
-});

package/src/cmd/project/auth/init.ts

@@ -1,256 +0,0 @@
-import enquirer from 'enquirer';
-import * as fs from 'fs';
-import * as path from 'path';
-import { z } from 'zod';
-import { getCommand } from '../../../command-prefix';
-import { readEnvFile, writeEnvFile } from '../../../env-util';
-import * as tui from '../../../tui';
-import { createSubcommand } from '../../../types';
-import {
-	detectOrmSetup,
-	ensureAuthDependencies,
-	generateAuthFileContent,
-	generateAuthSchemaSql,
-	getGeneratedSqlDir,
-	printIntegrationExamples,
-	runAuthMigrations,
-	selectOrCreateDatabase,
-} from './shared';
-
-export const initSubcommand = createSubcommand({
-	name: 'init',
-	description: 'Set up Agentuity Auth for your project',
-	tags: ['mutating', 'slow', 'requires-auth'],
-	requires: { auth: true, org: true },
-	idempotent: false,
-	examples: [
-		{
-			command: getCommand('project auth init'),
-			description: 'Set up Agentuity Auth with database selection',
-		},
-	],
-	schema: {
-		options: z.object({
-			skipMigrations: z
-				.boolean()
-				.optional()
-				.describe(
-					'Skip running database migrations (run `agentuity project auth generate` later)'
-				),
-		}),
-		response: z.object({
-			success: z.boolean().describe('Whether setup succeeded'),
-			database: z.string().optional().describe('Database name used'),
-			authFileCreated: z.boolean().describe('Whether auth.ts was created'),
-			migrationsRun: z.boolean().describe('Whether migrations were run'),
-		}),
-	},
-
-	async handler(ctx) {
-		const { logger, opts, auth, orgId, config } = ctx;
-
-		tui.newline();
-		tui.info(tui.bold('Agentuity Auth Setup'));
-		tui.newline();
-		tui.info('This will:');
-		console.log('  • Ensure you have a Postgres database configured');
-		console.log('  • Install @agentuity/auth');
-		console.log('  • Run database migrations to create auth tables');
-		console.log('  • Show you how to wire auth into your API and UI');
-		tui.newline();
-
-		const projectDir = process.cwd();
-
-		// Check for package.json
-		const packageJsonPath = path.join(projectDir, 'package.json');
-		if (!fs.existsSync(packageJsonPath)) {
-			tui.fatal('No package.json found. Run this command from your project root.');
-		}
-
-		// Step 1: Check for DATABASE_URL or select/create database
-		let databaseUrl = process.env.DATABASE_URL;
-
-		if (!databaseUrl) {
-			// Check .env file
-			const envPath = path.join(projectDir, '.env');
-			if (fs.existsSync(envPath)) {
-				const envContent = fs.readFileSync(envPath, 'utf-8');
-				const match = envContent.match(/^DATABASE_URL=(.+)$/m);
-				if (match?.[1]) {
-					databaseUrl = match[1].trim().replace(/^["']|["']$/g, '');
-				}
-			}
-		}
-
-		// Show database picker (with existing as first option if configured)
-		const dbInfo = await selectOrCreateDatabase({
-			logger,
-			auth,
-			orgId,
-			config,
-			existingUrl: databaseUrl,
-			projectDir,
-		});
-
-		// Get the region from the selected database
-		const region = dbInfo.region;
-
-		const databaseName = dbInfo.name;
-
-		// Update .env with database URL using proper parsing
-		const envPath = path.join(projectDir, '.env');
-		const existingEnv = await readEnvFile(envPath);
-
-		// Check if DATABASE_URL already exists
-		const hasDatabaseUrl = 'DATABASE_URL' in existingEnv;
-
-		if (dbInfo.url !== databaseUrl || !hasDatabaseUrl) {
-			if (hasDatabaseUrl) {
-				// DATABASE_URL exists, use AUTH_DATABASE_URL instead
-				await writeEnvFile(envPath, { AUTH_DATABASE_URL: dbInfo.url });
-				tui.success('AUTH_DATABASE_URL added to .env');
-				tui.warning(
-					`DATABASE_URL already exists. Update your ${tui.bold('src/auth.ts')} to use AUTH_DATABASE_URL.`
-				);
-			} else {
-				await writeEnvFile(envPath, { DATABASE_URL: dbInfo.url });
-				tui.success('DATABASE_URL added to .env');
-			}
-		} else {
-			tui.success(`Using database: ${databaseName}`);
-		}
-
-		// Add AGENTUITY_AUTH_SECRET if not present
-		// Re-read env to get latest state
-		const currentEnv = await readEnvFile(envPath);
-
-		const hasAuthSecret =
-			'AGENTUITY_AUTH_SECRET' in currentEnv || 'BETTER_AUTH_SECRET' in currentEnv;
-		if (!hasAuthSecret) {
-			const devSecret = `dev-${crypto.randomUUID()}-CHANGE-ME`;
-			await writeEnvFile(envPath, { AGENTUITY_AUTH_SECRET: devSecret });
-			tui.success('AGENTUITY_AUTH_SECRET added to .env (development default)');
-			tui.warning(
-				`Replace ${tui.bold('AGENTUITY_AUTH_SECRET')} with a secure value before deploying.`
-			);
-			tui.info(`Generate one with: ${tui.muted('openssl rand -hex 32')}`);
-		}
-
-		// Step 2: Install dependencies
-		tui.newline();
-		await ensureAuthDependencies({ projectDir, logger });
-
-		// Step 3: Generate auth.ts if it doesn't exist
-		const authFilePath = path.join(projectDir, 'src', 'auth.ts');
-		let authFileCreated = false;
-
-		if (fs.existsSync(authFilePath)) {
-			tui.info('src/auth.ts already exists, skipping generation');
-		} else {
-			const { createFile } = await enquirer.prompt<{ createFile: boolean }>({
-				type: 'confirm',
-				name: 'createFile',
-				message: 'Create src/auth.ts with default configuration?',
-				initial: true,
-			});
-
-			if (createFile) {
-				// Ensure src directory exists
-				const srcDir = path.join(projectDir, 'src');
-				if (!fs.existsSync(srcDir)) {
-					fs.mkdirSync(srcDir, { recursive: true });
-				}
-
-				fs.writeFileSync(authFilePath, generateAuthFileContent());
-				tui.success('Created src/auth.ts');
-				authFileCreated = true;
-			}
-		}
-
-		// Step 4: Run migrations (ORM-aware)
-		let migrationsRun = false;
-
-		if (opts.skipMigrations) {
-			tui.info('Skipping migrations (run `agentuity project auth generate` later)');
-		} else if (databaseName) {
-			tui.newline();
-
-			const ormSetup = await detectOrmSetup(projectDir);
-
-			if (ormSetup === 'drizzle') {
-				tui.info(tui.bold('Drizzle detected in your project.'));
-				tui.newline();
-				console.log(
-					'  Since you manage your own Drizzle schema, add authSchema to your schema:'
-				);
-				tui.newline();
-				console.log(tui.muted("    import * as authSchema from '@agentuity/auth/schema';"));
-				console.log(tui.muted('    export const schema = { ...authSchema, ...yourSchema };'));
-				tui.newline();
-				console.log('  Then run migrations:');
-				console.log(tui.muted('    bunx drizzle-kit push'));
-				tui.newline();
-			} else if (ormSetup === 'prisma') {
-				tui.info(tui.bold('Prisma detected in your project.'));
-				tui.newline();
-
-				const sql = await tui.spinner({
-					message: 'Preparing auth database schema...',
-					clearOnSuccess: true,
-					callback: () => generateAuthSchemaSql(logger, projectDir),
-				});
-
-				const sqlOutputDir = await getGeneratedSqlDir(projectDir);
-				const sqlFileName = 'agentuity-auth-schema.sql';
-				const sqlFilePath = path.join(sqlOutputDir, sqlFileName);
-				const relativePath =
-					sqlOutputDir === projectDir ? sqlFileName : path.relative(projectDir, sqlFilePath);
-				fs.writeFileSync(sqlFilePath, sql);
-				tui.success(`Auth schema SQL saved to ${tui.bold(relativePath)}`);
-				tui.newline();
-				console.log('  Run this SQL against your database to create auth tables.');
-				tui.newline();
-			} else {
-				const { runMigrations } = await enquirer.prompt<{ runMigrations: boolean }>({
-					type: 'confirm',
-					name: 'runMigrations',
-					message: 'Run database migrations now? (idempotent, safe to re-run)',
-					initial: true,
-				});
-
-				if (runMigrations) {
-					const sql = await tui.spinner({
-						message: 'Preparing auth database schema...',
-						clearOnSuccess: true,
-						callback: () => generateAuthSchemaSql(logger, projectDir),
-					});
-
-					await runAuthMigrations({
-						logger,
-						auth,
-						orgId,
-						region,
-						databaseName,
-						sql,
-						config,
-					});
-					migrationsRun = true;
-				}
-			}
-		} else {
-			tui.warning(
-				'Could not determine database name. Run `agentuity project auth generate` manually.'
-			);
-		}
-
-		// Step 5: Print integration examples
-		printIntegrationExamples();
-
-		return {
-			success: true,
-			database: databaseName,
-			authFileCreated,
-			migrationsRun,
-		};
-	},
-});