@agentuity/cli 2.0.10 → 2.0.12

package/src/cmd/build/vite/public-asset-path-plugin.ts

@@ -1,209 +0,0 @@
-/**
- * Vite plugin to fix incorrect public asset paths
- *
- * Developers should use /public/ paths for static assets from src/web/public/.
- * In production, these paths are transformed to CDN URLs.
- *
- * This plugin:
- * 1. During build: Rewrites /public/* paths to CDN URLs
- * 2. During dev: Warns only about incorrect source paths (src/web/public/)
- *
- * Supported patterns (work in dev, rewritten to CDN in production):
- * - '/public/foo.svg'          → CDN URL (recommended)
- * - './public/foo.svg'         → CDN URL
- * - 'url(/public/foo.svg)'    → CDN URL (CSS unquoted)
- * - 'url(./public/foo.svg)'   → CDN URL (CSS unquoted)
- *
- * Incorrect patterns (warned in dev, rewritten in production):
- * - '/src/web/public/foo.svg'  → CDN URL
- * - './src/web/public/foo.svg' → CDN URL
- * - 'src/web/public/foo.svg'   → CDN URL
- */
-
-import type { Plugin } from 'vite';
-
-export interface PublicAssetPathPluginOptions {
-	/** Whether to show warnings in dev mode (default: true) */
-	warnInDev?: boolean;
-	/** CDN base URL for production builds (e.g., 'https://cdn.agentuity.com/{deploymentId}/client/') */
-	cdnBaseUrl?: string;
-}
-
-interface PathPattern {
-	regex: RegExp;
-	description: string;
-	/** Replacement template - use {base} for the target base URL */
-	replacement: string;
-}
-
-/**
- * Patterns that are incorrect - reference source paths directly
- */
-function createIncorrectPatterns(): PathPattern[] {
-	return [
-		// '/src/web/public/...' or './src/web/public/...' or 'src/web/public/...'
-		{
-			regex: /(['"`])(?:\.?\/)?src\/web\/public\//g,
-			description: 'src/web/public/',
-			replacement: '$1{base}',
-		},
-	];
-}
-
-/**
- * Patterns that need rewriting for production CDN
- * Both patterns simply replace the prefix while preserving the rest of the path naturally.
- */
-function createPublicPatterns(): PathPattern[] {
-	return [
-		// './public/...' (relative public path) - replace prefix, keep rest
-		{
-			regex: /(['"`])\.\/public\//g,
-			description: './public/',
-			replacement: '$1{base}',
-		},
-		// '/public/...' (absolute public path) - replace prefix, keep rest
-		{
-			regex: /(['"`])\/public\//g,
-			description: '/public/',
-			replacement: '$1{base}',
-		},
-		// CSS url(/public/...) — unquoted path inside url()
-		{
-			regex: /url\(\/public\//g,
-			description: 'url(/public/)',
-			replacement: 'url({base}',
-		},
-		// CSS url(./public/...) — unquoted relative path inside url()
-		{
-			regex: /url\(\.\/public\//g,
-			description: 'url(./public/)',
-			replacement: 'url({base}',
-		},
-	];
-}
-
-/**
- * Vite plugin that fixes public asset paths and rewrites to CDN URLs
- *
- * Rewrites all public asset paths to CDN URLs in production.
- *
- * @example
- * // In vite config:
- * plugins: [publicAssetPathPlugin({ cdnBaseUrl: 'https://cdn.example.com/deploy/client/' })]
- *
- * // In code, use /public/ paths:
- * <img src="/public/logo.svg" />
- *
- * // Transforms in production:
- * // '/public/logo.svg' → 'https://cdn.example.com/deploy/client/logo.svg'
- */
-export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}): Plugin {
-	const { warnInDev = true, cdnBaseUrl } = options;
-
-	let isDev = false;
-	const warnedFiles = new Map<string, Set<string>>(); // file -> set of patterns warned
-
-	return {
-		name: 'agentuity:public-asset-path',
-
-		configResolved(config) {
-			isDev = config.command === 'serve';
-		},
-
-		transform(code, id) {
-			// Only transform files in src/web (browser code)
-			if (!id.includes('/src/web/') && !id.includes('\\src\\web\\')) {
-				return null;
-			}
-
-			// Quick check: does the code contain any patterns we care about?
-			const hasIncorrectSourcePaths = code.includes('src/web/public/');
-			const hasPublicPaths = code.includes('/public/') || code.includes('./public/');
-
-			if (!hasIncorrectSourcePaths && !hasPublicPaths) {
-				return null;
-			}
-
-			// In dev mode, only warn about incorrect source paths (src/web/public/)
-			// /public/ and ./public/ paths work correctly in dev mode
-			if (isDev) {
-				if (warnInDev && hasIncorrectSourcePaths) {
-					const patterns = createIncorrectPatterns();
-					const foundPatterns: string[] = [];
-
-					for (const { regex, description } of patterns) {
-						if (regex.test(code)) {
-							foundPatterns.push(description);
-						}
-					}
-
-					if (foundPatterns.length > 0) {
-						const fileWarnings = warnedFiles.get(id) || new Set();
-						const newWarnings = foundPatterns.filter((p) => !fileWarnings.has(p));
-
-						if (newWarnings.length > 0) {
-							for (const p of newWarnings) {
-								fileWarnings.add(p);
-							}
-							warnedFiles.set(id, fileWarnings);
-
-							this.warn(
-								`Found incorrect asset path(s) in ${id}:\n` +
-									newWarnings.map((p) => `  - '${p}' should be '/public/'`).join('\n') +
-									`\nUse '/public/...' paths for static assets.`
-							);
-						}
-					}
-				}
-				// In dev mode, never transform - Vite serves from source paths
-				// and the Bun server proxies /public/* to Vite
-				return null;
-			}
-
-			// Build mode: transform paths to CDN URLs
-			let transformed = code;
-
-			// Determine target URL: CDN base if provided, otherwise /public/
-			const targetBase = cdnBaseUrl
-				? cdnBaseUrl.endsWith('/')
-					? cdnBaseUrl
-					: `${cdnBaseUrl}/`
-				: '/public/';
-
-			// Transform incorrect source paths (src/web/public/) → CDN
-			if (hasIncorrectSourcePaths) {
-				const patterns = createIncorrectPatterns();
-				for (const { regex, replacement } of patterns) {
-					const replaceRegex = new RegExp(regex.source, regex.flags);
-					transformed = transformed.replace(
-						replaceRegex,
-						replacement.replace('{base}', targetBase)
-					);
-				}
-			}
-
-			// Transform public paths → CDN
-			if (hasPublicPaths) {
-				const publicPatterns = createPublicPatterns();
-				for (const { regex, replacement } of publicPatterns) {
-					const replaceRegex = new RegExp(regex.source, regex.flags);
-					transformed = transformed.replace(
-						replaceRegex,
-						replacement.replace('{base}', targetBase)
-					);
-				}
-			}
-
-			// Return transformed code if changed
-			if (transformed !== code) {
-				return {
-					code: transformed,
-					map: null,
-				};
-			}
-
-			return null;
-		},
-	};
-}

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,
-		};
-	},
-});