@arikajs/cli 0.0.3 → 0.0.5

package/dist/src/Commands/AuthApiInstallCommand.js

@@ -0,0 +1,751 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthApiInstallCommand = void 0;
+const console_1 = require("@arikajs/console");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+class AuthApiInstallCommand extends console_1.Command {
+    constructor() {
+        super(...arguments);
+        this.signature = 'auth:install:api {--force}';
+        this.description = 'Scaffold API authentication routes (JWT-based)';
+    }
+    async handle() {
+        this.info('Scaffolding authentication system...');
+        const force = this.option('force');
+        const cwd = process.cwd();
+        // Target Paths
+        const configPath = path_1.default.join(cwd, 'config', 'auth.ts');
+        const modelPath = path_1.default.join(cwd, 'app', 'Models', 'User.ts');
+        const authControllerDir = path_1.default.join(cwd, 'app', 'Http', 'Controllers', 'Auth');
+        const langEnDir = path_1.default.join(cwd, 'resources', 'lang', 'en');
+        const authLangPath = path_1.default.join(langEnDir, 'auth.json');
+        const validationLangPath = path_1.default.join(langEnDir, 'validation.json');
+        // Generate timestamped migration name
+        const date = new Date();
+        const baseTimestamp = date.getFullYear().toString() + '_' +
+            (date.getMonth() + 1).toString().padStart(2, '0') + '_' +
+            date.getDate().toString().padStart(2, '0') + '_' +
+            date.getHours().toString().padStart(2, '0') +
+            date.getMinutes().toString().padStart(2, '0');
+        const timestamp1 = baseTimestamp + date.getSeconds().toString().padStart(2, '0');
+        const timestamp2 = baseTimestamp + (date.getSeconds() + 1).toString().padStart(2, '0');
+        const migrationDir = path_1.default.join(cwd, 'database', 'migrations');
+        const usersMigrationPath = path_1.default.join(migrationDir, `${timestamp1}_create_users_table.ts`);
+        const passwordMigrationPath = path_1.default.join(migrationDir, `${timestamp2}_create_password_resets_table.ts`);
+        // Check if any file exists unless --force is used
+        if (!force) {
+            const existingFiles = [configPath, modelPath]
+                .filter(p => fs_1.default.existsSync(p));
+            if (existingFiles.length > 0) {
+                this.error('Authentication scaffold failed. The following files already exist:');
+                existingFiles.forEach(f => this.writeln(`  - ${f}`));
+                this.info('Use the --force flag to overwrite them.');
+                return;
+            }
+        }
+        // Ensure directories exist
+        [
+            path_1.default.dirname(configPath),
+            path_1.default.dirname(modelPath),
+            authControllerDir,
+            migrationDir,
+            langEnDir
+        ].forEach(dir => {
+            if (!fs_1.default.existsSync(dir))
+                fs_1.default.mkdirSync(dir, { recursive: true });
+        });
+        // Publish configuration and core files
+        fs_1.default.writeFileSync(configPath, this.getConfigStub());
+        fs_1.default.writeFileSync(modelPath, this.getModelStub());
+        // Publish Controllers
+        fs_1.default.writeFileSync(path_1.default.join(authControllerDir, 'LoginController.ts'), this.getLoginControllerStub());
+        fs_1.default.writeFileSync(path_1.default.join(authControllerDir, 'RegisterController.ts'), this.getRegisterControllerStub());
+        fs_1.default.writeFileSync(path_1.default.join(authControllerDir, 'ForgotPasswordController.ts'), this.getForgotPasswordControllerStub());
+        fs_1.default.writeFileSync(path_1.default.join(authControllerDir, 'ResetPasswordController.ts'), this.getResetPasswordControllerStub());
+        fs_1.default.writeFileSync(path_1.default.join(authControllerDir, 'VerifyEmailController.ts'), this.getVerifyEmailControllerStub());
+        // Publish Mailables
+        const mailAuthDir = path_1.default.join(cwd, 'app', 'Mail', 'Auth');
+        if (!fs_1.default.existsSync(mailAuthDir))
+            fs_1.default.mkdirSync(mailAuthDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(mailAuthDir, 'VerifyEmail.ts'), this.getVerifyEmailMailableStub());
+        fs_1.default.writeFileSync(path_1.default.join(mailAuthDir, 'ResetPassword.ts'), this.getResetPasswordMailableStub());
+        // Publish Email Views
+        const emailViewDir = path_1.default.join(cwd, 'resources', 'views', 'emails', 'auth');
+        if (!fs_1.default.existsSync(emailViewDir))
+            fs_1.default.mkdirSync(emailViewDir, { recursive: true });
+        const verifyViewPath = path_1.default.join(emailViewDir, 'verify_email.ark.html');
+        const resetViewPath = path_1.default.join(emailViewDir, 'reset_password.ark.html');
+        if (!fs_1.default.existsSync(verifyViewPath) || force) {
+            fs_1.default.writeFileSync(verifyViewPath, this.getVerifyEmailViewStub());
+        }
+        if (!fs_1.default.existsSync(resetViewPath) || force) {
+            fs_1.default.writeFileSync(resetViewPath, this.getResetPasswordViewStub());
+        }
+        // Publish Localization files
+        if (!fs_1.default.existsSync(authLangPath) || force) {
+            fs_1.default.writeFileSync(authLangPath, this.getAuthLangStub());
+        }
+        if (!fs_1.default.existsSync(validationLangPath) || force) {
+            fs_1.default.writeFileSync(validationLangPath, this.getValidationLangStub());
+        }
+        // Check if migrations already exist
+        const migrations = fs_1.default.existsSync(migrationDir) ? fs_1.default.readdirSync(migrationDir) : [];
+        if (!migrations.some(file => file.includes('create_users_table'))) {
+            fs_1.default.writeFileSync(usersMigrationPath, this.getUsersMigrationStub());
+        }
+        if (!migrations.some(file => file.includes('create_password_resets_table'))) {
+            fs_1.default.writeFileSync(passwordMigrationPath, this.getPasswordResetMigrationStub());
+        }
+        // Update Routes
+        this.appendRoutes();
+        this.updateEnv();
+        this.writeln('');
+        this.success('Premium API Authentication scaffolding generated successfully!');
+        this.info('Next steps:');
+        this.writeln(' 1. Run "arika migrate" to create the users table');
+        this.writeln(' 2. Use the "api" guard in your auth configuration');
+    }
+    updateEnv() {
+        const cwd = process.cwd();
+        const envPath = path_1.default.join(cwd, '.env');
+        if (!fs_1.default.existsSync(envPath))
+            return;
+        let content = fs_1.default.readFileSync(envPath, 'utf8');
+        if (!content.includes('JWT_SECRET=')) {
+            const secret = node_crypto_1.default.randomBytes(32).toString('hex');
+            content += `\n# Authentication\nJWT_SECRET=${secret}\n`;
+            fs_1.default.writeFileSync(envPath, content);
+            this.success('  ✅ JWT_SECRET has been automatically added to your .env file.');
+        }
+    }
+    getConfigStub() {
+        return `import { User } from '@Models/User';
+
+export default {
+    /*
+    |--------------------------------------------------------------------------
+    | Authentication Defaults
+    |--------------------------------------------------------------------------
+    |
+    | This option controls the default authentication "guard" and password
+    | reset options for your application.
+    |
+    */
+    default: 'api',
+
+    /*
+    |--------------------------------------------------------------------------
+    | Authentication Guards
+    |--------------------------------------------------------------------------
+    |
+    | Next, you may define every authentication guard for your application.
+    | Supported Drivers: "session", "jwt", "token", "basic"
+    |
+    */
+    guards: {
+        web: {
+            driver: 'session',
+            provider: 'users',
+        },
+        api: {
+            driver: 'jwt',
+            provider: 'users',
+            secret: process.env.JWT_SECRET || 'your-super-secret-jwt-key',
+            options: {
+                expiresIn: '24h',
+            },
+        },
+    },
+
+    /*
+    |--------------------------------------------------------------------------
+    | User Providers
+    |--------------------------------------------------------------------------
+    |
+    | All authentication drivers have a user provider. This defines how the
+    | users are actually retrieved out of your database.
+    |
+    */
+    providers: {
+        users: {
+            driver: 'eloquent',
+            model: User,
+        },
+    },
+
+    /*
+    |--------------------------------------------------------------------------
+    | Authentication Throttling & Locking
+    |--------------------------------------------------------------------------
+    |
+    */
+    lockout: {
+        maxAttempts: 5,
+        decayMinutes: 15,
+    },
+};
+`;
+    }
+    getModelStub() {
+        return `import { Model } from 'arikajs';
+
+export class User extends Model {
+    protected static table = 'users';
+
+    public declare id: number;
+    public declare name: string;
+    public declare email: string;
+    public declare password: string;
+    public declare email_verified_at: string | Date | null;
+
+    protected fillable: string[] = [
+        'name',
+        'email',
+        'password',
+        'email_verified_at',
+    ];
+
+    protected hidden: string[] = [
+        'password',
+    ];
+
+    public hasVerifiedEmail(): boolean {
+        return this.email_verified_at !== null;
+    }
+}
+`;
+    }
+    getUsersMigrationStub() {
+        return `import { Migration, SchemaBuilder } from 'arikajs';
+
+export default class CreateUsersTable extends Migration {
+    public async up(schema: SchemaBuilder): Promise<void> {
+        await schema.dropIfExists('users');
+        await schema.create('users', (table: any) => {
+            table.id();
+            table.string('name');
+            table.string('email').unique();
+            table.timestamp('email_verified_at').nullable();
+            table.string('password');
+            table.string('remember_token', 100).nullable();
+            table.string('refresh_token', 100).nullable();
+            table.timestamps();
+        });
+    }
+
+    public async down(schema: SchemaBuilder): Promise<void> {
+        await schema.dropIfExists('users');
+    }
+}
+`;
+    }
+    getPasswordResetMigrationStub() {
+        return `import { Migration, SchemaBuilder } from 'arikajs';
+
+export default class CreatePasswordResetsTable extends Migration {
+    public async up(schema: SchemaBuilder): Promise<void> {
+        await schema.dropIfExists('password_resets');
+        await schema.create('password_resets', (table: any) => {
+            table.string('email').index();
+            table.string('token');
+            table.timestamp('created_at').nullable();
+        });
+    }
+
+    public async down(schema: SchemaBuilder): Promise<void> {
+        await schema.dropIfExists('password_resets');
+    }
+}
+`;
+    }
+    getLoginControllerStub() {
+        return `import { Request, Response, Log, lang, app } from 'arikajs';
+import { User } from '@Models/User';
+
+export class LoginController {
+    /**
+     * Handle an incoming authentication request.
+     */
+    public async login(req: Request, res: Response) {
+        const credentials = await req.validate({
+            email: 'required|email',
+            password: 'required|string',
+        });
+
+        const guard = req.auth.guard('api');
+        const result = await guard.attempt(credentials);
+
+        if (!result) {
+            Log.info('Failed login attempt', { email: credentials.email });
+            return res.json({ error: lang('auth.failed') }, 401);
+        }
+
+        const user = await guard.user();
+
+        // JwtGuard.attempt() returns { access_token, refresh_token? } on success
+        const access_token = typeof result === 'object' && result.access_token 
+            ? result.access_token 
+            : (typeof result === 'string' ? result : undefined);
+
+        return res.json({ 
+            message: lang('auth.login_success'),
+            access_token,
+            user 
+        });
+    }
+
+    /**
+     * Get the authenticated user.
+     */
+    public async me(req: Request, res: Response) {
+        const user = await req.auth.guard('api').user() as User | null;
+        if (!user) {
+            return res.json({ error: lang('auth.unauthenticated') }, 401);
+        }
+        return res.json({ user });
+    }
+
+    /**
+     * Log the user out of the application.
+     */
+    public async logout(req: Request, res: Response) {
+        try {
+            await req.auth.guard('api').logout();
+        } catch (e) {
+            Log.error('Logout error', { error: (e as Error).message });
+        }
+        
+        return res.json({ message: lang('auth.logout_success') });
+    }
+}
+`;
+    }
+    getRegisterControllerStub() {
+        return `import { Request, Response, Mail, Hasher, config, Log, lang, app } from 'arikajs';
+import { User } from '@Models/User';
+import { VerifyEmail } from '@Mail/Auth/VerifyEmail';
+
+export class RegisterController {
+    /**
+     * Handle a registration request for the application.
+     */
+    public async register(req: Request, res: Response) {
+        const { name, email, password } = await req.validate({
+            name: 'required|string|min:2',
+            email: 'required|email',
+            password: 'required|string|min:8|confirmed',
+        });
+
+        const existingUser = await User.where('email', email).first();
+        if (existingUser) {
+            return res.json({ error: lang('auth.email_taken') }, 409);
+        }
+
+        const hashedPassword = await Hasher.make(password);
+
+        const user = await User.create({
+            name,
+            email,
+            password: hashedPassword,
+            email_verified_at: null
+        });
+
+        // Send Verification Email
+        const appName = config('app.name', 'ArikaJS App');
+        const appUrl = config('app.url', 'http://localhost:3000');
+        const verificationUrl = \`\${appUrl}/api/auth/verify?email=\${encodeURIComponent(email)}&token=\${Buffer.from(email).toString('base64')}\`;
+
+        try {
+            await Mail.to(email).send(new VerifyEmail(name, verificationUrl, appName));
+        } catch (e) {
+            Log.error('Failed to send verification email', { error: (e as Error).message, email });
+        }
+
+        // Return response (JWT logic)
+        let token = undefined;
+        const guard = req.auth.guard('api');
+        if (guard && (guard.constructor.name === 'JwtGuard' || (guard as any).issueTokens)) {
+            const result = await (guard as any).issueTokens(user);
+            token = result.access_token;
+        }
+
+        return res.json({ 
+            message: lang('auth.register_success'),
+            access_token: token,
+            user 
+        });
+    }
+}
+`;
+    }
+    getForgotPasswordControllerStub() {
+        return `import { Request, Response, Mail, config, Log, lang, DB } from 'arikajs';
+import { User } from '@Models/User';
+import { ResetPassword } from '@Mail/Auth/ResetPassword';
+import { VerifyEmail } from '@Mail/Auth/VerifyEmail';
+import * as crypto from 'crypto';
+
+export class ForgotPasswordController {
+    /**
+     * Send a reset link to the given user.
+     */
+    public async sendResetLinkEmail(req: Request, res: Response) {
+        const { email } = await req.validate({
+            email: 'required|email',
+        });
+        const user = await User.where('email', email).first() as User | null;
+
+        if (!user) {
+            return res.json({ error: lang('auth.user_not_found') }, 404);
+        }
+
+        const appName = config('app.name', 'ArikaJS App');
+        const appUrl = config('app.url', 'http://localhost:3000');
+
+        // Check if user is verified
+        if (user.hasVerifiedEmail && !user.hasVerifiedEmail()) {
+            const verificationUrl = \`\${appUrl}/api/auth/verify?email=\${encodeURIComponent(email)}&token=\${Buffer.from(email).toString('base64')}\`;
+            
+            try {
+                // Send verification link instead
+                await Mail.to(email).send(new VerifyEmail(user.name, verificationUrl, appName));
+                return res.json({ 
+                    message: "Account unverified. A new verification link has been sent to your email." 
+                });
+            } catch (e) {
+                Log.error('Failed to send verification email', { error: (e as Error).message, email });
+            }
+        }
+
+        // Proceed with Password Reset
+        const token = crypto.randomBytes(32).toString('hex');
+
+        await DB.table('password_resets').where('email', email).delete();
+        await DB.table('password_resets').insert({
+            email,
+            token,
+            created_at: new Date()
+        });
+
+        const resetUrl = \`\${appUrl}/api/auth/password/reset?email=\${encodeURIComponent(email)}&token=\${token}\`;
+
+        try {
+            await Mail.to(email).send(new ResetPassword(resetUrl, appName));
+        } catch (e) {
+            Log.error('Failed to send reset email', { error: (e as Error).message, email });
+        }
+        
+        return res.json({ message: lang('auth.reset_link_sent') });
+    }
+}
+`;
+    }
+    getResetPasswordControllerStub() {
+        return `import { Request, Response, Hasher, lang, DB } from 'arikajs';
+import { User } from '@Models/User';
+
+export class ResetPasswordController {
+    /**
+     * Reset the given user's password.
+     */
+    public async reset(req: Request, res: Response) {
+        const { token, email, password } = await req.validate({
+            token: 'required|string',
+            email: 'required|email',
+            password: 'required|string|min:8|confirmed'
+        });
+        
+        // Verify token against database
+        const resetRecord = await DB.table('password_resets').where('email', email).where('token', token).first();
+        if (!resetRecord) {
+            return res.json({ error: lang('auth.invalid_reset_token') }, 403);
+        }
+
+        const user = await User.where('email', email).first() as User | null;
+        if (!user) {
+            return res.json({ error: lang('auth.user_not_found') }, 404);
+        }
+
+        await user.update({
+            password: await Hasher.make(password)
+        });
+
+        // Delete the used token
+        await DB.table('password_resets').where('email', email).delete();
+
+        return res.json({ message: lang('auth.password_reset_success') });
+    }
+}
+`;
+    }
+    getVerifyEmailControllerStub() {
+        return `import { Request, Response, Mail, config, Log, lang } from 'arikajs';
+import { User } from '@Models/User';
+import { VerifyEmail } from '@Mail/Auth/VerifyEmail';
+
+export class VerifyEmailController {
+    /**
+     * Mark the authenticated user's email address as verified.
+     */
+    public async verify(req: Request, res: Response) {
+        const { email, token } = req.all();
+
+        if (!email || !token) {
+            return res.json({ error: lang('auth.missing_verification_data') }, 400);
+        }
+
+        const expectedToken = Buffer.from(email).toString('base64');
+        if (token !== expectedToken) {
+            Log.warning('Invalid email verification attempt', { email, token });
+            return res.json({ error: lang('auth.invalid_verification_token') }, 403);
+        }
+
+        const user = await User.where('email', email).first() as User | null;
+        if (!user) {
+            return res.json({ error: lang('auth.user_not_found') }, 404);
+        }
+
+        if (user.email_verified_at) {
+            return res.json({ message: lang('auth.email_already_verified') });
+        }
+
+        try {
+            await user.update({
+                email_verified_at: new Date()
+            });
+        } catch (e) {
+            Log.error('Email verification update failed', { error: (e as Error).message, email });
+            return res.json({ error: lang('auth.verification_failed') }, 500);
+        }
+
+        return res.json({ message: lang('auth.email_verified') });
+    }
+
+    /**
+     * Resend the email verification notification.
+     * The user is already authenticated via the auth middleware.
+     */
+    public async resend(req: Request, res: Response) {
+        // Get the authenticated user directly from the JWT guard
+        const user = await req.auth.guard('api').user() as User | null;
+
+        if (!user) {
+            return res.json({ error: lang('auth.unauthenticated') }, 401);
+        }
+
+        if (user.email_verified_at) {
+            return res.json({ message: lang('auth.email_already_verified') });
+        }
+
+        const appName = config('app.name', 'ArikaJS App');
+        const appUrl = config('app.url', 'http://localhost:3000');
+        const verificationUrl = \`\${appUrl}/api/auth/verify?email=\${encodeURIComponent(user.email)}&token=\${Buffer.from(user.email).toString('base64')}\`;
+
+        try {
+            await Mail.to(user.email).send(new VerifyEmail(user.name, verificationUrl, appName));
+        } catch (e) {
+            Log.error('Failed to resend verification email', { error: (e as Error).message, email: user.email });
+            return res.json({ error: lang('auth.verification_failed') }, 500);
+        }
+
+        return res.json({ message: lang('auth.verification_resent') });
+    }
+}
+`;
+    }
+    getVerifyEmailMailableStub() {
+        return `import { Mailable } from 'arikajs';
+
+export class VerifyEmail extends Mailable {
+    constructor(
+        private name: string,
+        private verificationUrl: string,
+        private appName: string
+    ) {
+        super();
+    }
+
+    public build() {
+        return this.subject('Verify Your Email Address')
+            .view('emails/auth/verify_email', {
+                name: this.name,
+                verification_url: this.verificationUrl,
+                app_name: this.appName,
+                year: new Date().getFullYear()
+            });
+    }
+}
+`;
+    }
+    getResetPasswordMailableStub() {
+        return `import { Mailable } from 'arikajs';
+
+export class ResetPassword extends Mailable {
+    constructor(
+        private resetUrl: string,
+        private appName: string
+    ) {
+        super();
+    }
+
+    public build() {
+        return this.subject('Reset Password Notification')
+            .view('emails/auth/reset_password', {
+                reset_url: this.resetUrl,
+                app_name: this.appName,
+                year: new Date().getFullYear()
+            });
+    }
+}
+`;
+    }
+    appendRoutes() {
+        const cwd = process.cwd();
+        const apiRoutesPath = path_1.default.join(cwd, 'routes', 'api.ts');
+        if (!fs_1.default.existsSync(apiRoutesPath))
+            return;
+        let content = fs_1.default.readFileSync(apiRoutesPath, 'utf8');
+        // Add imports if they don't exist
+        const imports = [
+            "import { LoginController } from '@Controllers/Auth/LoginController';",
+            "import { RegisterController } from '@Controllers/Auth/RegisterController';",
+            "import { ForgotPasswordController } from '@Controllers/Auth/ForgotPasswordController';",
+            "import { ResetPasswordController } from '@Controllers/Auth/ResetPasswordController';",
+            "import { VerifyEmailController } from '@Controllers/Auth/VerifyEmailController';"
+        ];
+        imports.forEach(imp => {
+            if (!content.includes(imp)) {
+                content = imp + "\n" + content;
+            }
+        });
+        if (!content.includes("Route.group({ prefix: 'auth'")) {
+            const routeDefinitions = `
+// Authentication Routes (API)
+Route.group({ prefix: 'auth' }, () => {
+    Route.post('/register', [RegisterController, 'register']);
+    Route.post('/login', [LoginController, 'login']);
+    Route.post('/logout', [LoginController, 'logout']).withMiddleware('auth:api');
+
+    // Email Verification
+    Route.get('/verify', [VerifyEmailController, 'verify']);
+    Route.post('/verification-notification', [VerifyEmailController, 'resend']).withMiddleware('auth:api');
+
+    // Password Reset
+    Route.post('/password/email', [ForgotPasswordController, 'sendResetLinkEmail']);
+    Route.post('/password/reset', [ResetPasswordController, 'reset']);
+});
+
+Route.get('/user', [LoginController, 'me']).withMiddleware('auth:api');
+`;
+            content += routeDefinitions;
+        }
+        fs_1.default.writeFileSync(apiRoutesPath, content);
+    }
+    getAuthLangStub() {
+        return JSON.stringify({
+            "failed": "These credentials do not match our records.",
+            "failed_required": "Email and password are required.",
+            "throttle": "Too many login attempts. Please try again in :seconds seconds.",
+            "login_success": "Successfully logged in.",
+            "logout_success": "Successfully logged out.",
+            "register_success": "Registration successful! Please check your email to verify your account.",
+            "email_taken": "This email is already registered.",
+            "unauthenticated": "You must be logged in to access this resource.",
+            "email_verified": "Email address verified successfully!",
+            "email_already_verified": "Email address is already verified.",
+            "verification_failed": "Email verification failed. The link may be expired or invalid.",
+            "verification_resent": "Verification link has been resent to your email address.",
+            "missing_verification_data": "Missing verification data (email or token).",
+            "invalid_verification_token": "The verification token is invalid.",
+            "user_not_found": "We could not find a user with that email address.",
+            "reset_link_sent": "If that email is registered, a password reset link has been sent.",
+            "invalid_reset_token": "The password reset token is invalid.",
+            "password_reset_success": "Your password has been reset successfully. You can now log in.",
+            "email_not_verified": "Your email address is not verified. Please verify your email before attempting to reset your password."
+        }, null, 4);
+    }
+    getValidationLangStub() {
+        return JSON.stringify({
+            "failed": "The given data was invalid.",
+            "required": "The :attribute field is required.",
+            "email": "The :attribute must be a valid email address.",
+            "min": {
+                "string": "The :attribute must be at least :min characters."
+            },
+            "confirmed": "The :attribute confirmation does not match."
+        }, null, 4);
+    }
+    getVerifyEmailViewStub() {
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Verify Your Email - {{ config('app.name', 'ArikaJS') }}</title>
+    <style>
+        body { margin: 0; padding: 0; font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background-color: #f4f4f7; color: #51545e; }
+        .wrapper { width: 100%; margin: 0; padding: 0; -webkit-text-size-adjust: none; background-color: #f4f4f7; }
+        .content { width: 100%; max-width: 570px; margin: 0 auto; padding: 35px; background-color: #ffffff; border-radius: 8px; box-shadow: 0 2px 0 rgba(0, 0, 150, 0.025), 2px 4px 0 rgba(0, 0, 150, 0.015); }
+        .header { padding: 25px 0; text-align: center; }
+        .header a { font-size: 19px; font-weight: bold; color: #333; text-decoration: none; }
+        .button { display: inline-block; background-color: #22bc66; color: #FFF !important; padding: 12px 25px; text-decoration: none; border-radius: 3px; font-weight: bold; }
+        .footer { text-align: center; padding: 25px; font-size: 12px; color: #b0adc5; }
+    </style>
+</head>
+<body>
+    <div class="wrapper">
+        <div class="header"><a href="#">{{ app_name }}</a></div>
+        <div class="content">
+            <h1>Verify your email address</h1>
+            <p>Hi {{ name }},</p>
+            <p>Thanks for signing up! Please confirm your email address by clicking the button below.</p>
+            <p style="text-align: center;"><a href="{{ verification_url }}" class="button">Verify Email</a></p>
+            <p>If you did not create an account, no further action is required.</p>
+            <p>Regards,<br>{{ app_name }} Team</p>
+        </div>
+        <div class="footer">&copy; {{ year }} {{ app_name }}. All rights reserved.</div>
+    </div>
+</body>
+</html>`;
+    }
+    getResetPasswordViewStub() {
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Reset Password - {{ config('app.name', 'ArikaJS') }}</title>
+    <style>
+        body { margin: 0; padding: 0; font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background-color: #f4f4f7; color: #51545e; }
+        .wrapper { width: 100%; margin: 0; padding: 0; -webkit-text-size-adjust: none; background-color: #f4f4f7; }
+        .content { width: 100%; max-width: 570px; margin: 0 auto; padding: 35px; background-color: #ffffff; border-radius: 8px; box-shadow: 0 2px 0 rgba(0, 0, 150, 0.025), 2px 4px 0 rgba(0, 0, 150, 0.015); }
+        .header { padding: 25px 0; text-align: center; }
+        .header a { font-size: 19px; font-weight: bold; color: #333; text-decoration: none; }
+        .button { display: inline-block; background-color: #3869d4; color: #FFF !important; padding: 12px 25px; text-decoration: none; border-radius: 3px; font-weight: bold; }
+        .footer { text-align: center; padding: 25px; font-size: 12px; color: #b0adc5; }
+    </style>
+</head>
+<body>
+    <div class="wrapper">
+        <div class="header"><a href="#">{{ app_name }}</a></div>
+        <div class="content">
+            <h1>Reset your password</h1>
+            <p>You are receiving this email because we received a password reset request for your account.</p>
+            <p style="text-align: center;"><a href="{{ reset_url }}" class="button">Reset Password</a></p>
+            <p>This password reset link will expire in 60 minutes.</p>
+            <p>If you did not request a password reset, no further action is required.</p>
+            <p>Regards,<br>{{ app_name }} Team</p>
+        </div>
+        <div class="footer">&copy; {{ year }} {{ app_name }}. All rights reserved.</div>
+    </div>
+</body>
+</html>`;
+    }
+}
+exports.AuthApiInstallCommand = AuthApiInstallCommand;
+//# sourceMappingURL=AuthApiInstallCommand.js.map