@agentuity/cli 3.0.0-alpha.6 → 3.0.0-beta.0

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

@@ -1,566 +0,0 @@
-/**
- * Shared helpers for Agentuity Auth setup
- */
-
-import * as path from 'node:path';
-import { createResources, dbQuery, listOrgResources } from '@agentuity/server';
-import enquirer from 'enquirer';
-import {
-	getCatalystAPIClient,
-	getGlobalCatalystAPIClient,
-	loadProjectConfig,
-	ProjectConfigNotFoundException,
-} from '../../../config';
-import * as tui from '../../../tui';
-import type { AuthData, Config, Logger } from '../../../types';
-
-/**
- * Database info returned from selection
- */
-export interface DatabaseInfo {
-	name: string;
-	url: string;
-	region: string;
-}
-
-/**
- * Select an existing database or create a new one.
- * When creating a new database, uses the project's region from agentuity.json if available.
- */
-export async function selectOrCreateDatabase(options: {
-	logger: Logger;
-	auth: AuthData;
-	orgId: string;
-	config: Config | null;
-	existingUrl?: string;
-	projectDir?: string;
-}): Promise<DatabaseInfo> {
-	const { logger, auth, orgId, config, existingUrl, projectDir } = options;
-	const profileName = config?.name;
-	const globalClient = await getGlobalCatalystAPIClient(
-		logger,
-		auth,
-		profileName,
-		undefined,
-		config
-	);
-
-	const resources = await tui.spinner({
-		message: `Fetching databases for ${orgId}`,
-		clearOnSuccess: true,
-		callback: async () => listOrgResources(globalClient, { type: 'db', orgId }),
-	});
-
-	const databases = resources.db;
-
-	// Extract existing database name from URL if provided
-	let existingDbName: string | undefined;
-	if (existingUrl) {
-		const urlMatch = existingUrl.match(/\/([^/?]+)(\?|$)/);
-		if (urlMatch) {
-			existingDbName = urlMatch[1];
-		}
-	}
-
-	type Choice = { name: string; message: string };
-	const choices: Choice[] = [];
-
-	// Add "use existing" option first if we have an existing URL
-	if (existingUrl && existingDbName) {
-		choices.push({
-			name: '__existing__',
-			message: `${tui.tuiColors.success('✓')} Use existing (found in .env): ${existingDbName}`,
-		});
-	}
-
-	// Add create new option
-	choices.push({ name: '__create__', message: tui.bold('+ Create new database') });
-
-	// Add other databases
-	choices.push(
-		...databases
-			.filter((db) => db.name !== existingDbName) // Don't duplicate existing
-			.map((db) => ({
-				name: db.name,
-				message: db.name,
-			}))
-	);
-
-	const response = await enquirer.prompt<{ database: string }>({
-		type: 'select',
-		name: 'database',
-		message: 'Select a database for auth:',
-		choices,
-	});
-
-	// Handle "use existing" selection
-	if (response.database === '__existing__' && existingUrl && existingDbName) {
-		// Find the database to get its region
-		const existingDb = databases.find((d) => d.name === existingDbName);
-		const region = existingDb?.cloud_region ?? 'usc';
-		return { name: existingDbName, url: existingUrl, region };
-	}
-
-	if (response.database === '__create__') {
-		// For creating a new database, determine the region:
-		// 1. Try to get from project's agentuity.json
-		// 2. Fall back to first existing database's region
-		// 3. Fall back to 'usc' as default
-		let region: string | undefined;
-
-		if (projectDir) {
-			try {
-				const projectConfig = await loadProjectConfig(projectDir, config);
-				region = projectConfig.region;
-				logger.trace(`[auth init] Using region from project config: ${region}`);
-			} catch (err) {
-				if (!(err instanceof ProjectConfigNotFoundException)) {
-					logger.trace(`[auth init] Error loading project config: ${err}`);
-				}
-			}
-		}
-
-		if (!region) {
-			const firstDb = databases[0];
-			region = firstDb ? firstDb.cloud_region : 'usc';
-			logger.trace(`[auth init] Using fallback region: ${region}`);
-		}
-
-		const regionalClient = getCatalystAPIClient(logger, auth, region, undefined, config);
-
-		const created = await tui.spinner({
-			message: `Creating database in ${region}`,
-			clearOnSuccess: true,
-			callback: async () => createResources(regionalClient, orgId, region, [{ type: 'db' }]),
-		});
-
-		const newDb = created[0];
-		if (!newDb) {
-			tui.fatal('Failed to create database');
-		}
-
-		tui.success(`Created database: ${tui.bold(newDb.name)}`);
-
-		// Fetch updated list to get the URL
-		const updatedResources = await listOrgResources(globalClient, { type: 'db', orgId });
-		const dbInfo = updatedResources.db.find((d) => d.name === newDb.name);
-
-		if (!dbInfo?.url) {
-			tui.fatal('Failed to retrieve database connection URL');
-			// TypeScript doesn't know fatal never returns, so we need this
-			throw new Error('Unreachable');
-		}
-
-		return { name: newDb.name, url: dbInfo.url, region };
-	}
-
-	const selectedDb = databases.find((d) => d.name === response.database);
-	if (!selectedDb?.url) {
-		tui.fatal('Failed to retrieve database connection URL');
-		// TypeScript doesn't know fatal never returns, so we need this
-		throw new Error('Unreachable');
-	}
-
-	return { name: selectedDb.name, url: selectedDb.url, region: selectedDb.cloud_region };
-}
-
-/**
- * Required auth dependencies
- */
-export const AUTH_DEPENDENCIES = {
-	'@agentuity/auth': 'latest',
-	'better-auth': '^1.4.9',
-	'drizzle-orm': '^0.45.0',
-	'drizzle-kit': '^0.31.0',
-} as const;
-
-/**
- * Check and install auth dependencies
- */
-export async function ensureAuthDependencies(options: {
-	projectDir: string;
-	logger: Logger;
-}): Promise<boolean> {
-	const { projectDir } = options;
-	const fs = await import('fs');
-	const path = await import('path');
-
-	const packageJsonPath = path.join(projectDir, 'package.json');
-
-	if (!fs.existsSync(packageJsonPath)) {
-		tui.fatal('No package.json found in project directory');
-	}
-
-	const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-	const deps = packageJson.dependencies || {};
-
-	const missingDeps: string[] = [];
-
-	for (const [dep, version] of Object.entries(AUTH_DEPENDENCIES)) {
-		if (!deps[dep]) {
-			missingDeps.push(`${dep}@${version}`);
-		}
-	}
-
-	if (missingDeps.length === 0) {
-		return false;
-	}
-
-	tui.info(`Installing auth dependencies: ${missingDeps.join(', ')}`);
-
-	const proc = Bun.spawn(['bun', 'install', ...missingDeps], {
-		cwd: projectDir,
-		stdout: 'inherit',
-		stderr: 'inherit',
-	});
-
-	const exitCode = await proc.exited;
-	if (exitCode !== 0) {
-		throw new Error(`bun install failed with code ${exitCode}`);
-	}
-
-	tui.success('Dependencies installed');
-	return true;
-}
-
-/**
- * ORM setup type detected in a project.
- */
-export type OrmSetup = 'drizzle' | 'prisma' | 'none';
-
-/**
- * Get the directory for generated SQL files.
- * Uses src/generated/ if it exists, otherwise falls back to project root.
- */
-export async function getGeneratedSqlDir(projectDir: string): Promise<string> {
-	const generatedDir = path.join(projectDir, 'src', 'generated');
-	if (await Bun.file(path.join(generatedDir, 'registry.ts')).exists()) {
-		return generatedDir;
-	}
-	return projectDir;
-}
-
-/**
- * Detect existing ORM setup in project.
- * TODO: This is probably not 100% accurate. Drizzle config could be in all sorts of places in a repo.
- */
-export async function detectOrmSetup(projectDir: string): Promise<OrmSetup> {
-	const drizzleConfigTs = path.join(projectDir, 'drizzle.config.ts');
-	const drizzleConfigJs = path.join(projectDir, 'drizzle.config.js');
-	const prismaSchema = path.join(projectDir, 'prisma', 'schema.prisma');
-
-	if ((await Bun.file(drizzleConfigTs).exists()) || (await Bun.file(drizzleConfigJs).exists())) {
-		return 'drizzle';
-	}
-
-	if (await Bun.file(prismaSchema).exists()) {
-		return 'prisma';
-	}
-
-	return 'none';
-}
-
-/**
- * Generate auth schema SQL using drizzle-kit export.
- *
- * This generates SQL DDL statements from the @agentuity/auth Drizzle schema
- * without needing a database connection.
- *
- * @param logger - Logger instance
- * @param projectDir - Project directory (must have @agentuity/auth installed)
- * @returns SQL DDL statements for auth tables
- */
-export async function generateAuthSchemaSql(logger: Logger, projectDir: string): Promise<string> {
-	const schemaPath = path.join(projectDir, 'node_modules/@agentuity/auth/dist/schema.js');
-
-	if (!(await Bun.file(schemaPath).exists())) {
-		throw new Error(
-			`@agentuity/auth schema not found at ${schemaPath}. Ensure @agentuity/auth is installed.`
-		);
-	}
-
-	const proc = Bun.spawn(
-		['bunx', '--bun', 'drizzle-kit', 'export', '--dialect=postgresql', `--schema=${schemaPath}`],
-		{
-			cwd: projectDir,
-			stdout: 'pipe',
-			stderr: 'pipe',
-		}
-	);
-
-	const [stdout, stderr, exitCode] = await Promise.all([
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-		proc.exited,
-	]);
-
-	if (stderr !== '') {
-		logger.error('drizzle-kit export failed', { stderr });
-	}
-	if (stdout !== '') {
-		logger.trace('drizzle-kit export stdout', { stdout });
-	}
-
-	if (exitCode !== 0 || stderr !== '') {
-		const errorMsg = stderr
-			.split('\n')
-			.filter((line) => !line.includes('Please install'))
-			.join('\n')
-			.trim();
-		throw new Error(`drizzle-kit export failed with code ${exitCode}: ${errorMsg}`);
-	}
-
-	return makeIdempotent(stdout);
-}
-
-/**
- * Transform drizzle-kit SQL output to be idempotent.
- *
- * - Converts CREATE TABLE to CREATE TABLE IF NOT EXISTS
- * - Converts CREATE INDEX to CREATE INDEX IF NOT EXISTS
- * - Wraps ALTER TABLE ADD CONSTRAINT in DO blocks to handle existing constraints
- */
-function makeIdempotent(sql: string): string {
-	const lines = sql.split('\n');
-	const result: string[] = [];
-
-	for (const line of lines) {
-		const trimmed = line.trim();
-
-		if (trimmed.startsWith('CREATE TABLE ') && !trimmed.includes('IF NOT EXISTS')) {
-			result.push(line.replace('CREATE TABLE ', 'CREATE TABLE IF NOT EXISTS '));
-		} else if (trimmed.startsWith('CREATE INDEX ') && !trimmed.includes('IF NOT EXISTS')) {
-			result.push(line.replace('CREATE INDEX ', 'CREATE INDEX IF NOT EXISTS '));
-		} else if (trimmed.startsWith('ALTER TABLE ') && trimmed.includes('ADD CONSTRAINT')) {
-			const constraintMatch = trimmed.match(/ADD CONSTRAINT "([^"]+)"/);
-			if (constraintMatch) {
-				result.push(
-					`DO $$ BEGIN ${trimmed} EXCEPTION WHEN duplicate_object THEN NULL; END $$;`
-				);
-			} else {
-				result.push(line);
-			}
-		} else {
-			result.push(line);
-		}
-	}
-
-	return result.join('\n');
-}
-
-/**
- * Split SQL into individual statements for sequential execution
- * The dbQuery API only supports single statements
- */
-export function splitSqlStatements(sql: string): string[] {
-	// Split on semicolons, but be careful about edge cases
-	const statements: string[] = [];
-	let current = '';
-
-	for (const line of sql.split('\n')) {
-		const trimmed = line.trim();
-
-		// Skip empty lines and comments
-		if (!trimmed || trimmed.startsWith('--')) {
-			continue;
-		}
-
-		current += line + '\n';
-
-		// If line ends with semicolon, it's end of statement
-		if (trimmed.endsWith(';')) {
-			const stmt = current.trim();
-			if (stmt && stmt !== ';') {
-				statements.push(stmt);
-			}
-			current = '';
-		}
-	}
-
-	// Handle any remaining content
-	if (current.trim()) {
-		statements.push(current.trim());
-	}
-
-	return statements;
-}
-
-/**
- * Run auth migrations against a database.
- *
- * @param options.sql - SQL to execute (from generateAuthSchemaSql or custom)
- */
-export async function runAuthMigrations(options: {
-	logger: Logger;
-	auth: AuthData;
-	orgId: string;
-	region: string;
-	databaseName: string;
-	sql: string;
-	config?: Config | null;
-}): Promise<void> {
-	const { logger, auth, orgId, region, databaseName, sql, config } = options;
-	const catalystClient = getCatalystAPIClient(logger, auth, region, undefined, config);
-
-	const statements = splitSqlStatements(sql);
-
-	await tui.spinner({
-		message: `Creating auth tables in database "${databaseName}" (${statements.length} SQL statements)`,
-		clearOnSuccess: true,
-		callback: async () => {
-			for (const statement of statements) {
-				await dbQuery(catalystClient, {
-					database: databaseName,
-					query: statement,
-					orgId,
-					region,
-				});
-			}
-		},
-	});
-
-	tui.success(`Auth tables created in ${tui.bold(databaseName)}`);
-}
-
-/**
- * Generate the auth.ts file content
- */
-export function generateAuthFileContent(): string {
-	return `/**
- * Agentuity Auth configuration.
- *
- * This is the single source of truth for authentication in this project.
- * All auth tables are stored in your Postgres database.
- */
-
-import {
-	createAuth,
-	createSessionMiddleware,
-	createApiKeyMiddleware,
-} from '@agentuity/auth';
-
-/**
- * Database URL for authentication.
- *
- * Set via DATABASE_URL environment variable.
- * Get yours from: \`agentuity cloud database list --region use --json\`
- */
-const DATABASE_URL = process.env.DATABASE_URL;
-
-if (!DATABASE_URL) {
-	throw new Error('DATABASE_URL environment variable is required for authentication');
-}
-
-/**
- * Agentuity Auth instance with sensible defaults.
- *
- * Defaults:
- * - basePath: '/api/auth'
- * - emailAndPassword: { enabled: true }
- * - Uses AGENTUITY_AUTH_SECRET env var for signing
- *
- * Default plugins included:
- * - organization (multi-tenancy)
- * - jwt (token signing)
- * - bearer (API auth)
- * - apiKey (programmatic access)
- */
-export const auth = createAuth({
-	// Simplest setup: just provide the connection string
-	// We create pg pool + Drizzle internally with joins enabled
-	connectionString: DATABASE_URL,
-	// All options below have sensible defaults and can be omitted:
-	// secret: process.env.AGENTUITY_AUTH_SECRET, // auto-resolved from env
-	// basePath: '/api/auth', // default
-	// emailAndPassword: { enabled: true }, // default
-});
-
-/**
- * Session middleware - validates cookies/bearer tokens.
- * Use for routes that require authentication.
- */
-export const authMiddleware = createSessionMiddleware(auth);
-
-/**
- * Optional auth middleware - allows anonymous access.
- * Sets ctx.auth = null for unauthenticated requests.
- */
-export const optionalAuthMiddleware = createSessionMiddleware(auth, { optional: true });
-
-/**
- * API key middleware for programmatic access.
- * Use for webhook endpoints or external integrations.
- */
-export const apiKeyMiddleware = createApiKeyMiddleware(auth);
-
-/**
- * Optional API key middleware - continues without auth if no API key present.
- */
-export const optionalApiKeyMiddleware = createApiKeyMiddleware(auth, { optional: true });
-
-/**
- * Type export for end-to-end type safety.
- */
-export type Auth = typeof auth;
-`;
-}
-
-/**
- * Print integration examples to the console
- */
-export function printIntegrationExamples(): void {
-	tui.newline();
-	tui.info(tui.bold('Next Steps - Add these to your project:'));
-	tui.newline();
-
-	console.log(tui.muted('━'.repeat(60)));
-	console.log(tui.bold(' 1. Set up your API routes:'));
-	console.log(tui.muted('━'.repeat(60)));
-	console.log(`
-import { Hono } from 'hono';
-import { mountAuthRoutes } from '@agentuity/auth';
-import { auth, authMiddleware } from './auth';
-
-const app = new Hono();
-
-// Mount auth routes (sign-in, sign-up, sign-out, session, etc.)
-app.on(['GET', 'POST'], '/api/auth/*', mountAuthRoutes(auth));
-
-// Protect your API routes with auth middleware
-app.use('/api/*', authMiddleware);
-
-app.get('/api/me', async (c) => {
-  const user = await c.var.auth.getUser();
-  return c.json({ id: user.id, email: user.email });
-});
-
-export default app;
-`);
-
-	console.log(tui.muted('━'.repeat(60)));
-	console.log(tui.bold(' 2. Use the auth client in your frontend:'));
-	console.log(tui.muted('━'.repeat(60)));
-	console.log(`
-import { createAuthClient } from '@agentuity/auth/client';
-
-const authClient = createAuthClient();
-
-// Sign in
-await authClient.signIn.email({ email, password });
-
-// Get session
-const session = await authClient.getSession();
-`);
-
-	tui.newline();
-	console.log(tui.muted('━'.repeat(60)));
-	tui.info('Checklist:');
-	console.log(`  ${tui.tuiColors.success('✓')} DATABASE_URL configured`);
-	console.log(`  ${tui.tuiColors.success('✓')} AGENTUITY_AUTH_SECRET configured`);
-	console.log(`  ${tui.tuiColors.success('✓')} Auth tables migrated`);
-	console.log(`  ${tui.tuiColors.success('✓')} Dependencies installed`);
-	console.log(`  ${tui.muted('○')} Wire Hono middleware`);
-	console.log(`  ${tui.muted('○')} Add auth routes (mountAuthRoutes at /api/auth/*)`);
-	console.log(`  ${tui.muted('○')} Wrap app with AuthProvider`);
-	tui.newline();
-}

package/src/cmd/project/create.ts

@@ -1,134 +0,0 @@
-import { createSubcommand, type CommandContext, type AuthData } from '../../types';
-import { z } from 'zod';
-import { runCreateFlow } from './template-flow';
-import { getCommand } from '../../command-prefix';
-import type { APIClient as APIClientType } from '../../api';
-
-const ProjectCreateResponseSchema = z.object({
-	success: z.boolean().describe('Whether the operation succeeded'),
-	error: z.string().optional().describe('Error message if setup failed'),
-	name: z.string().describe('Project name'),
-	path: z.string().describe('Project directory path'),
-	projectId: z.string().optional().describe('Project ID if registered'),
-	orgId: z.string().optional().describe('Organization ID if registered'),
-	framework: z.string().describe('Framework used'),
-	installed: z.boolean().describe('Whether dependencies were installed'),
-	built: z.boolean().describe('Whether the project was built'),
-	domains: z.array(z.string()).optional().describe('Array of custom domains'),
-});
-
-export const createProjectSubcommand = createSubcommand({
-	name: 'create',
-	description: 'Create a new project',
-	tags: ['mutating', 'creates-resource', 'slow'],
-	aliases: ['new', 'init'],
-	banner: true,
-	toplevel: true,
-	idempotent: false,
-	optional: { auth: true, region: true, apiClient: true },
-	examples: [
-		{ command: getCommand('project create'), description: 'Create new project' },
-		{
-			command: getCommand('project create --name my-ai-app'),
-			description: 'Create named project',
-		},
-		{
-			command: getCommand('project create --name my-app --framework nextjs'),
-			description: 'Create with Next.js',
-		},
-		{
-			command: getCommand('project create --framework hono --no-install'),
-			description: 'Scaffold without installing',
-		},
-		{ command: getCommand('project new --no-register'), description: 'Skip cloud registration' },
-	],
-	schema: {
-		options: z.object({
-			name: z.string().optional().describe('Project name'),
-			dir: z.string().optional().describe('Directory to create the project in'),
-			domains: z.array(z.string()).optional().describe('Array of custom domains'),
-			framework: z
-				.string()
-				.optional()
-				.describe(
-					'Framework to use (e.g., nextjs, astro, sveltekit, remix, nuxt, hono, vite-react)'
-				),
-			install: z
-				.boolean()
-				.optional()
-				.default(true)
-				.describe('Run bun install after creating the project (use --no-install to skip)'),
-			build: z
-				.boolean()
-				.optional()
-				.default(true)
-				.describe('Run bun run build after installing (use --no-build to skip)'),
-			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
-			register: z
-				.boolean()
-				.default(true)
-				.optional()
-				.describe('Register the project, if authenticated (use --no-register to skip)'),
-			database: z
-				.string()
-				.optional()
-				.describe('Database action: "skip", "new", or existing database name'),
-			storage: z
-				.string()
-				.optional()
-				.describe('Storage action: "skip", "new", or existing bucket name'),
-			enableAuth: z.boolean().optional().describe('Enable Agentuity Auth'),
-		}),
-		response: ProjectCreateResponseSchema,
-	},
-
-	async handler(ctx) {
-		const { logger, opts, auth, config, apiClient, region, options } = ctx;
-
-		// Only get org if registering
-		let orgId: string | undefined;
-		if (opts.register === true && auth && apiClient) {
-			const { optionalOrg } = await import('../../auth');
-			orgId = await optionalOrg(
-				ctx as CommandContext & { apiClient?: APIClientType; auth?: AuthData }
-			);
-		}
-
-		const result = await runCreateFlow({
-			projectName: opts.name,
-			dir: opts.dir,
-			domains: opts.domains,
-			framework: opts.framework,
-			noInstall: opts.install === false,
-			noBuild: opts.build === false,
-			skipPrompts: opts.confirm === true,
-			logger,
-			auth: opts.register === true ? auth : undefined,
-			config: config!,
-			apiClient,
-			orgId: opts.register === true ? orgId : undefined,
-			region,
-			database: opts.database,
-			storage: opts.storage,
-			enableAuth: opts.enableAuth,
-		});
-
-		// Exit with error code if setup failed and not in JSON mode
-		if (!result.success && !options.json) {
-			process.exitCode = 1;
-		}
-
-		return {
-			success: result.success,
-			error: result.error,
-			name: result.name,
-			path: result.path,
-			projectId: result.projectId,
-			orgId: result.orgId,
-			framework: result.framework,
-			installed: result.installed,
-			built: result.built,
-			domains: result.domains,
-		};
-	},
-});