hazo_auth 1.6.0 → 1.6.2

package/dist/app/api/hazo_auth/library_photos/route.d.ts

@@ -4,9 +4,18 @@ export declare function GET(request: NextRequest): Promise<NextResponse<{
     success: boolean;
     category: string;
     photos: string[];
+    pagination: {
+        page: number;
+        page_size: number;
+        total: number;
+        has_more: boolean;
+        total_pages: number;
+    };
+    source: "project" | "node_modules";
 }> | NextResponse<{
     success: boolean;
     categories: string[];
+    source: "project" | "node_modules" | null;
 }> | NextResponse<{
     error: string;
 }>>;

package/dist/app/api/hazo_auth/library_photos/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/library_photos/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAMxD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAGvC,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;IA4D7C"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/library_photos/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAUxD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAOvC,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;IAmF7C"}

package/dist/app/api/hazo_auth/library_photos/route.js

@@ -1,43 +1,68 @@
-// file_description: API route for listing library photo categories and photos in categories
+// file_description: API route for listing library photo categories and photos in categories with pagination support
 // section: imports
 import { NextResponse } from "next/server";
-import { get_library_categories, get_library_photos } from "../../../../lib/services/profile_picture_service";
+import { get_library_categories, get_library_photos_paginated, get_library_source } from "../../../../lib/services/profile_picture_service";
 import { create_app_logger } from "../../../../lib/app_logger";
 import { get_filename, get_line_number } from "../../../../lib/utils/api_route_helpers";
 // section: route_config
 export const dynamic = 'force-dynamic';
+// section: constants
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 100;
 // section: api_handler
 export async function GET(request) {
     const logger = create_app_logger();
     try {
         const { searchParams } = new URL(request.url);
         const category = searchParams.get("category");
+        const page_param = searchParams.get("page");
+        const page_size_param = searchParams.get("page_size");
+        // Parse pagination parameters
+        const page = page_param ? Math.max(1, parseInt(page_param, 10) || 1) : 1;
+        const page_size = page_size_param
+            ? Math.min(MAX_PAGE_SIZE, Math.max(1, parseInt(page_size_param, 10) || DEFAULT_PAGE_SIZE))
+            : DEFAULT_PAGE_SIZE;
         if (category) {
-            // Return photos in the specified category
-            const photos = get_library_photos(category);
+            // Return photos in the specified category with pagination
+            const result = get_library_photos_paginated(category, page, page_size);
             logger.info("library_photos_category_requested", {
                 filename: get_filename(),
                 line_number: get_line_number(),
                 category,
-                photoCount: photos.length,
+                page,
+                page_size,
+                total: result.total,
+                returned: result.photos.length,
+                source: result.source,
             });
             return NextResponse.json({
                 success: true,
                 category,
-                photos,
+                photos: result.photos,
+                pagination: {
+                    page: result.page,
+                    page_size: result.page_size,
+                    total: result.total,
+                    has_more: result.has_more,
+                    total_pages: Math.ceil(result.total / result.page_size),
+                },
+                source: result.source,
             }, { status: 200 });
         }
         else {
             // Return list of categories
             const categories = get_library_categories();
+            const source = get_library_source();
             logger.info("library_categories_requested", {
                 filename: get_filename(),
                 line_number: get_line_number(),
                 categoryCount: categories.length,
+                source,
             });
             return NextResponse.json({
                 success: true,
                 categories,
+                source,
             }, { status: 200 });
         }
     }

package/dist/cli/generate.d.ts

@@ -1,2 +1,7 @@
-export declare function generate_routes(custom_app_dir?: string): void;
+export type GenerateOptions = {
+    dir?: string;
+    pages?: boolean;
+    all?: boolean;
+};
+export declare function generate_routes(options?: GenerateOptions): void;
 //# sourceMappingURL=generate.d.ts.map

package/dist/cli/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/cli/generate.ts"],"names":[],"mappings":"AA0EA,wBAAgB,eAAe,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAwE7D"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/cli/generate.ts"],"names":[],"mappings":"AAqBA,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf,CAAC;AAwJF,wBAAgB,eAAe,CAAC,OAAO,GAAE,eAAoB,GAAG,IAAI,CA8DnE"}

package/dist/cli/generate.js

@@ -1,5 +1,5 @@
-// file_description: route generation logic for hazo_auth
-// This module creates API route files in consuming projects
+// file_description: route and page generation logic for hazo_auth
+// This module creates API route files and page files in consuming projects
 import * as fs from "fs";
 import * as path from "path";
 // section: constants
@@ -17,11 +17,21 @@ const ROUTES = [
     { name: "upload_profile_picture", path: "api/hazo_auth/upload_profile_picture", method: "POST", export_name: "uploadProfilePicturePOST" },
     { name: "remove_profile_picture", path: "api/hazo_auth/remove_profile_picture", method: "DELETE", export_name: "removeProfilePictureDELETE" },
     { name: "library_photos", path: "api/hazo_auth/library_photos", method: "GET", export_name: "libraryPhotosGET" },
+    { name: "library_photo", path: "api/hazo_auth/library_photo/[category]/[filename]", method: "GET", export_name: "libraryPhotoGET" },
     { name: "get_auth", path: "api/hazo_auth/get_auth", method: "POST", export_name: "getAuthPOST" },
     { name: "validate_reset_token", path: "api/hazo_auth/validate_reset_token", method: "GET", export_name: "validateResetTokenGET" },
     { name: "profile_picture_filename", path: "api/hazo_auth/profile_picture/[filename]", method: "GET", export_name: "profilePictureFilenameGET" },
     { name: "invalidate_cache", path: "api/hazo_auth/invalidate_cache", method: "POST", export_name: "invalidateCachePOST" },
 ];
+const PAGES = [
+    { name: "login", path: "hazo_auth/login", component_name: "LoginPage", import_path: "hazo_auth/pages/login" },
+    { name: "register", path: "hazo_auth/register", component_name: "RegisterPage", import_path: "hazo_auth/pages/register" },
+    { name: "forgot_password", path: "hazo_auth/forgot_password", component_name: "ForgotPasswordPage", import_path: "hazo_auth/pages/forgot_password" },
+    { name: "reset_password", path: "hazo_auth/reset_password", component_name: "ResetPasswordPage", import_path: "hazo_auth/pages/reset_password" },
+    { name: "verify_email", path: "hazo_auth/verify_email", component_name: "VerifyEmailPage", import_path: "hazo_auth/pages/verify_email" },
+    { name: "my_settings", path: "hazo_auth/my_settings", component_name: "MySettingsPage", import_path: "hazo_auth/pages/my_settings" },
+];
+// Note: The import_path uses "hazo_auth/pages/*" which maps to dist/page_components/* in package.json exports
 // section: helpers
 function get_project_root() {
     return process.cwd();
@@ -43,6 +53,9 @@ function ensure_dir(dir_path) {
         fs.mkdirSync(dir_path, { recursive: true });
     }
 }
+function file_exists(filepath) {
+    return fs.existsSync(filepath);
+}
 function generate_route_content(route) {
     return `// Generated by hazo_auth - do not edit manually
 // Route: /${route.path}
@@ -50,32 +63,20 @@ function generate_route_content(route) {
 export { ${route.export_name} as ${route.method} } from "hazo_auth/server/routes";
 `;
 }
-function file_exists(filepath) {
-    return fs.existsSync(filepath);
+function generate_page_content(page) {
+    return `// Generated by hazo_auth - do not edit manually
+// Page: /${page.path}
+import { ${page.component_name} } from "${page.import_path}";
+
+export default ${page.component_name};
+`;
 }
-// section: main
-export function generate_routes(custom_app_dir) {
-    const project_root = get_project_root();
-    console.log("\n\x1b[1m🐸 hazo_auth Route Generator\x1b[0m");
-    console.log("=".repeat(50));
-    console.log(`Project root: ${project_root}\n`);
-    let app_dir = custom_app_dir
-        ? path.join(project_root, custom_app_dir)
-        : find_app_dir(project_root);
-    if (!app_dir) {
-        console.error("\x1b[31mError: Could not find app directory.\x1b[0m");
-        console.log("Try specifying it with: npx hazo_auth generate-routes --dir=src/app");
-        process.exit(1);
-    }
-    if (!fs.existsSync(app_dir)) {
-        console.error(`\x1b[31mError: App directory not found: ${app_dir}\x1b[0m`);
-        process.exit(1);
-    }
-    console.log(`App directory: ${app_dir.replace(project_root, ".")}\n`);
+// section: api_route_generation
+function generate_api_routes(app_dir, project_root) {
     let created = 0;
     let skipped = 0;
     let errors = 0;
-    console.log("\x1b[1mGenerating routes...\x1b[0m\n");
+    console.log("\x1b[1m📡 Generating API routes...\x1b[0m\n");
     for (const route of ROUTES) {
         const route_dir = path.join(app_dir, route.path);
         const route_file = path.join(route_dir, "route.ts");
@@ -96,22 +97,88 @@ export function generate_routes(custom_app_dir) {
             errors++;
         }
     }
+    return { created, skipped, errors };
+}
+// section: page_generation
+function generate_page_routes(app_dir, project_root) {
+    let created = 0;
+    let skipped = 0;
+    let errors = 0;
+    console.log("\n\x1b[1m📄 Generating page routes...\x1b[0m\n");
+    for (const page of PAGES) {
+        const page_dir = path.join(app_dir, page.path);
+        const page_file = path.join(page_dir, "page.tsx");
+        if (file_exists(page_file)) {
+            console.log(`\x1b[33m[SKIP]\x1b[0m ${page.path}/page.tsx (already exists)`);
+            skipped++;
+            continue;
+        }
+        try {
+            ensure_dir(page_dir);
+            const content = generate_page_content(page);
+            fs.writeFileSync(page_file, content, "utf-8");
+            console.log(`\x1b[32m[CREATE]\x1b[0m ${page.path}/page.tsx`);
+            created++;
+        }
+        catch (err) {
+            console.log(`\x1b[31m[ERROR]\x1b[0m ${page.path}/page.tsx - ${err instanceof Error ? err.message : "Unknown error"}`);
+            errors++;
+        }
+    }
+    return { created, skipped, errors };
+}
+// section: main
+export function generate_routes(options = {}) {
+    const { dir, pages = false, all = false } = options;
+    const project_root = get_project_root();
+    const include_pages = pages || all;
+    console.log("\n\x1b[1m🐸 hazo_auth Route Generator\x1b[0m");
+    console.log("=".repeat(50));
+    console.log(`Project root: ${project_root}`);
+    console.log(`Mode: ${include_pages ? "API routes + Pages" : "API routes only"}\n`);
+    const app_dir = dir
+        ? path.join(project_root, dir)
+        : find_app_dir(project_root);
+    if (!app_dir) {
+        console.error("\x1b[31mError: Could not find app directory.\x1b[0m");
+        console.log("Try specifying it with: npx hazo_auth generate-routes --dir=src/app");
+        process.exit(1);
+    }
+    if (!fs.existsSync(app_dir)) {
+        console.error(`\x1b[31mError: App directory not found: ${app_dir}\x1b[0m`);
+        process.exit(1);
+    }
+    console.log(`App directory: ${app_dir.replace(project_root, ".")}\n`);
+    // Generate API routes
+    const api_result = generate_api_routes(app_dir, project_root);
+    // Generate pages if requested
+    let page_result = { created: 0, skipped: 0, errors: 0 };
+    if (include_pages) {
+        page_result = generate_page_routes(app_dir, project_root);
+    }
+    // Summary
+    const total_created = api_result.created + page_result.created;
+    const total_skipped = api_result.skipped + page_result.skipped;
+    const total_errors = api_result.errors + page_result.errors;
     console.log("\n" + "=".repeat(50));
     console.log("\x1b[1mSummary:\x1b[0m");
-    console.log(`  \x1b[32m✓ Created: ${created}\x1b[0m`);
-    console.log(`  \x1b[33m⊘ Skipped: ${skipped}\x1b[0m`);
-    if (errors > 0) {
-        console.log(`  \x1b[31m✗ Errors:  ${errors}\x1b[0m`);
+    console.log(`  \x1b[32m✓ Created: ${total_created}\x1b[0m (${api_result.created} routes, ${page_result.created} pages)`);
+    console.log(`  \x1b[33m⊘ Skipped: ${total_skipped}\x1b[0m`);
+    if (total_errors > 0) {
+        console.log(`  \x1b[31m✗ Errors:  ${total_errors}\x1b[0m`);
     }
     console.log();
-    if (created > 0) {
-        console.log("\x1b[32m🦊 Routes generated successfully!\x1b[0m");
+    if (total_created > 0) {
+        console.log("\x1b[32m🦊 Generation complete!\x1b[0m");
         console.log("\nNext steps:");
         console.log("  1. Run `npm run dev` to start your development server");
-        console.log("  2. Test the routes with `curl http://localhost:3000/api/hazo_auth/me`");
-        console.log("  3. Visit http://localhost:3000/api/hazo_auth/health to check setup status\n");
+        console.log("  2. Test API: `curl http://localhost:3000/api/hazo_auth/me`");
+        if (include_pages) {
+            console.log("  3. Visit http://localhost:3000/hazo_auth/login to test pages");
+        }
+        console.log();
     }
-    else if (skipped === ROUTES.length) {
-        console.log("\x1b[33m🦊 All routes already exist. No changes made.\x1b[0m\n");
+    else if (total_skipped === ROUTES.length + (include_pages ? PAGES.length : 0)) {
+        console.log("\x1b[33m🦊 All files already exist. No changes made.\x1b[0m\n");
     }
 }

package/dist/cli/index.js

@@ -4,25 +4,29 @@
 // section: imports
 import { run_validation } from "./validate.js";
 import { generate_routes } from "./generate.js";
+import { handle_init } from "./init.js";
 // section: constants
-const VERSION = "1.5.0";
+const VERSION = "1.6.0";
 const HELP_TEXT = `
 \x1b[1m🐸 hazo_auth CLI v${VERSION}\x1b[0m
 
 Usage: hazo_auth <command> [options]
 
 Commands:
+  init               Initialize hazo_auth in your project (creates directories, copies config)
   validate           Check your hazo_auth setup and configuration
-  generate-routes    Generate API route files in your project
+  generate-routes    Generate API route files and pages in your project
 
 Options:
   --help, -h         Show this help message
   --version, -v      Show version number
 
 Examples:
+  npx hazo_auth init
   npx hazo_auth validate
   npx hazo_auth generate-routes
-  npx hazo_auth generate-routes --dir=src/app
+  npx hazo_auth generate-routes --pages
+  npx hazo_auth generate-routes --all --dir=src/app
 
 Documentation:
   https://github.com/your-repo/hazo_auth/blob/main/SETUP_CHECKLIST.md
@@ -61,33 +65,42 @@ async function handle_validate() {
     process.exit(summary.failed > 0 ? 1 : 0);
 }
 function handle_generate_routes(args) {
-    // Parse --dir argument
-    let dir;
+    const options = {};
     for (const arg of args) {
         if (arg.startsWith("--dir=")) {
-            dir = arg.replace("--dir=", "");
+            options.dir = arg.replace("--dir=", "");
+        }
+        else if (arg === "--pages") {
+            options.pages = true;
+        }
+        else if (arg === "--all") {
+            options.all = true;
         }
         else if (arg === "--help" || arg === "-h") {
             console.log(`
 hazo_auth generate-routes
 
-Generate API route files in your Next.js project.
+Generate API route files and page files in your Next.js project.
 
 Usage:
   hazo_auth generate-routes [options]
 
 Options:
   --dir=<path>    Specify the app directory (default: auto-detect)
+  --pages         Generate page routes in addition to API routes
+  --all           Generate everything (API routes + pages)
   --help, -h      Show this help message
 
 Examples:
-  hazo_auth generate-routes
-  hazo_auth generate-routes --dir=src/app
+  hazo_auth generate-routes               # API routes only
+  hazo_auth generate-routes --pages       # API routes + pages
+  hazo_auth generate-routes --all         # Same as --pages
+  hazo_auth generate-routes --dir=src/app # Specify app directory
 `);
             return;
         }
     }
-    generate_routes(dir);
+    generate_routes(options);
 }
 // section: main
 async function main() {
@@ -96,12 +109,52 @@ async function main() {
         show_version();
         return;
     }
-    if (help || !command) {
+    // Show main help only if no command specified
+    if (!command) {
         show_help();
         return;
     }
+    // If help is requested but command exists, pass help to command handler
+    // Commands can show their own help
+    if (help) {
+        args.push("--help");
+    }
     switch (command) {
+        case "init":
+            if (help) {
+                console.log(`
+hazo_auth init
+
+Initialize hazo_auth in your project.
+
+Actions:
+  - Creates public/profile_pictures/library/ directory
+  - Creates public/profile_pictures/uploads/ directory
+  - Creates data/ directory (for SQLite)
+  - Copies hazo_auth_config.ini and hazo_notify_config.ini
+  - Copies profile picture library images
+  - Creates .env.local.example template
+`);
+                return;
+            }
+            handle_init();
+            break;
         case "validate":
+            if (help) {
+                console.log(`
+hazo_auth validate
+
+Check your hazo_auth setup and configuration.
+
+This command verifies:
+  - Config files exist and are readable
+  - Required config values are set
+  - Environment variables are configured
+  - Database connection works
+  - Required directories exist
+`);
+                return;
+            }
             await handle_validate();
             break;
         case "generate-routes":

package/dist/cli/init.d.ts

@@ -0,0 +1,2 @@
+export declare function handle_init(): void;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/cli/init.ts"],"names":[],"mappings":"AA2IA,wBAAgB,WAAW,IAAI,IAAI,CAkHlC"}

package/dist/cli/init.js

@@ -0,0 +1,206 @@
+// file_description: init command for hazo_auth
+// Creates directories and copies config files to consuming projects
+import { fileURLToPath } from "url";
+import * as fs from "fs";
+import * as path from "path";
+// section: esm_shim
+// ESM-compatible __dirname shim
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// section: constants
+const REQUIRED_DIRECTORIES = [
+    "public/profile_pictures/library",
+    "public/profile_pictures/uploads",
+    "data",
+];
+const CONFIG_FILES = [
+    { source: "hazo_auth_config.example.ini", target: "hazo_auth_config.ini" },
+    { source: "hazo_notify_config.example.ini", target: "hazo_notify_config.ini" },
+];
+// section: helpers
+function get_project_root() {
+    return process.cwd();
+}
+function get_package_root() {
+    // When running from node_modules, we need to find the hazo_auth package root
+    // When running in development, use the current directory
+    // Check if we're in node_modules
+    const parts = __dirname.split(path.sep);
+    const node_modules_index = parts.lastIndexOf("node_modules");
+    if (node_modules_index !== -1) {
+        // We're in node_modules/hazo_auth/dist/cli
+        return parts.slice(0, node_modules_index + 2).join(path.sep);
+    }
+    // Development mode - go up from src/cli or dist/cli
+    return path.resolve(__dirname, "..", "..");
+}
+function ensure_dir(dir_path) {
+    if (!fs.existsSync(dir_path)) {
+        fs.mkdirSync(dir_path, { recursive: true });
+        return true;
+    }
+    return false;
+}
+function copy_file_if_not_exists(source, target) {
+    if (fs.existsSync(target)) {
+        return "skipped";
+    }
+    if (!fs.existsSync(source)) {
+        return "error";
+    }
+    try {
+        fs.copyFileSync(source, target);
+        return "created";
+    }
+    catch (_a) {
+        return "error";
+    }
+}
+function copy_directory(source, target) {
+    let copied = 0;
+    if (!fs.existsSync(source)) {
+        return 0;
+    }
+    ensure_dir(target);
+    const items = fs.readdirSync(source);
+    for (const item of items) {
+        const source_path = path.join(source, item);
+        const target_path = path.join(target, item);
+        const stat = fs.statSync(source_path);
+        if (stat.isDirectory()) {
+            copied += copy_directory(source_path, target_path);
+        }
+        else if (!fs.existsSync(target_path)) {
+            fs.copyFileSync(source_path, target_path);
+            copied++;
+        }
+    }
+    return copied;
+}
+function create_gitkeep(dir_path) {
+    const gitkeep_path = path.join(dir_path, ".gitkeep");
+    if (!fs.existsSync(gitkeep_path)) {
+        const files = fs.readdirSync(dir_path);
+        if (files.length === 0) {
+            fs.writeFileSync(gitkeep_path, "# This file keeps the empty directory in git\n");
+        }
+    }
+}
+function create_env_template(project_root) {
+    const env_example_path = path.join(project_root, ".env.local.example");
+    if (fs.existsSync(env_example_path)) {
+        return false;
+    }
+    const content = `# hazo_auth environment variables
+# Copy this file to .env.local and fill in the values
+
+# Required for email functionality (email verification, password reset)
+ZEPTOMAIL_API_KEY=your_zeptomail_api_key_here
+
+# Optional: Database path (defaults to data/hazo_auth.sqlite)
+# HAZO_AUTH_DB_PATH=./data/hazo_auth.sqlite
+`;
+    fs.writeFileSync(env_example_path, content);
+    return true;
+}
+// section: main
+export function handle_init() {
+    const project_root = get_project_root();
+    const package_root = get_package_root();
+    console.log("\n\x1b[1m🐸 hazo_auth Initialization\x1b[0m");
+    console.log("=".repeat(50));
+    console.log(`Project root: ${project_root}`);
+    console.log(`Package root: ${package_root}\n`);
+    const result = {
+        directories_created: [],
+        files_copied: [],
+        skipped: [],
+        errors: [],
+    };
+    // Step 1: Create directories
+    console.log("\x1b[1m📁 Creating directories...\x1b[0m\n");
+    for (const dir of REQUIRED_DIRECTORIES) {
+        const full_path = path.join(project_root, dir);
+        if (ensure_dir(full_path)) {
+            console.log(`\x1b[32m[CREATE]\x1b[0m ${dir}/`);
+            result.directories_created.push(dir);
+        }
+        else {
+            console.log(`\x1b[33m[EXISTS]\x1b[0m ${dir}/`);
+            result.skipped.push(dir);
+        }
+    }
+    // Step 2: Copy config files
+    console.log("\n\x1b[1m📄 Copying config files...\x1b[0m\n");
+    for (const config of CONFIG_FILES) {
+        const source_path = path.join(package_root, config.source);
+        const target_path = path.join(project_root, config.target);
+        const status = copy_file_if_not_exists(source_path, target_path);
+        if (status === "created") {
+            console.log(`\x1b[32m[CREATE]\x1b[0m ${config.target}`);
+            result.files_copied.push(config.target);
+        }
+        else if (status === "skipped") {
+            console.log(`\x1b[33m[EXISTS]\x1b[0m ${config.target}`);
+            result.skipped.push(config.target);
+        }
+        else {
+            console.log(`\x1b[31m[ERROR]\x1b[0m ${config.target} - source not found: ${source_path}`);
+            result.errors.push(config.target);
+        }
+    }
+    // Step 3: Copy profile picture library
+    console.log("\n\x1b[1m🖼️  Copying profile picture library...\x1b[0m\n");
+    const library_source = path.join(package_root, "public", "profile_pictures", "library");
+    const library_target = path.join(project_root, "public", "profile_pictures", "library");
+    if (fs.existsSync(library_source)) {
+        const copied_count = copy_directory(library_source, library_target);
+        if (copied_count > 0) {
+            console.log(`\x1b[32m[COPY]\x1b[0m ${copied_count} library images`);
+            result.files_copied.push(`${copied_count} library images`);
+        }
+        else {
+            console.log(`\x1b[33m[EXISTS]\x1b[0m Library images already present`);
+            result.skipped.push("library images");
+        }
+    }
+    else {
+        console.log(`\x1b[33m[SKIP]\x1b[0m Library not found at: ${library_source}`);
+        result.skipped.push("library images (source not found)");
+    }
+    // Step 4: Create .gitkeep files for empty directories
+    console.log("\n\x1b[1m📌 Creating .gitkeep files...\x1b[0m\n");
+    const empty_dirs = ["public/profile_pictures/uploads", "data"];
+    for (const dir of empty_dirs) {
+        const full_path = path.join(project_root, dir);
+        if (fs.existsSync(full_path)) {
+            create_gitkeep(full_path);
+            console.log(`\x1b[32m[CREATE]\x1b[0m ${dir}/.gitkeep`);
+        }
+    }
+    // Step 5: Create .env.local.example template
+    console.log("\n\x1b[1m🔑 Creating environment template...\x1b[0m\n");
+    if (create_env_template(project_root)) {
+        console.log(`\x1b[32m[CREATE]\x1b[0m .env.local.example`);
+        result.files_copied.push(".env.local.example");
+    }
+    else {
+        console.log(`\x1b[33m[EXISTS]\x1b[0m .env.local.example`);
+        result.skipped.push(".env.local.example");
+    }
+    // Summary
+    console.log("\n" + "=".repeat(50));
+    console.log("\x1b[1mSummary:\x1b[0m");
+    console.log(`  \x1b[32m✓ Created:\x1b[0m ${result.directories_created.length} directories, ${result.files_copied.length} files`);
+    console.log(`  \x1b[33m⊘ Skipped:\x1b[0m ${result.skipped.length} items`);
+    if (result.errors.length > 0) {
+        console.log(`  \x1b[31m✗ Errors:\x1b[0m ${result.errors.length}`);
+    }
+    console.log("\n\x1b[32m🦊 Initialization complete!\x1b[0m");
+    console.log("\nNext steps:");
+    console.log("  1. Edit \x1b[36mhazo_auth_config.ini\x1b[0m with your settings");
+    console.log("  2. Copy \x1b[36m.env.local.example\x1b[0m to \x1b[36m.env.local\x1b[0m and add your API keys");
+    console.log("  3. Run \x1b[36mnpx hazo_auth generate-routes --pages\x1b[0m to generate routes and pages");
+    console.log("  4. Run \x1b[36mnpx hazo_auth validate\x1b[0m to check your setup");
+    console.log();
+}

package/dist/client.d.ts

@@ -0,0 +1,8 @@
+export * from "./components/index";
+export { cn, merge_class_names } from "./lib/utils";
+export * from "./lib/auth/auth_types";
+export { use_auth_status, trigger_auth_status_refresh } from "./components/layouts/shared/hooks/use_auth_status";
+export { use_hazo_auth, trigger_hazo_auth_refresh } from "./components/layouts/shared/hooks/use_hazo_auth";
+export type { UseHazoAuthOptions, UseHazoAuthResult } from "./components/layouts/shared/hooks/use_hazo_auth";
+export * from "./components/layouts/shared/utils/validation";
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAYA,cAAc,oBAAoB,CAAC;AAInC,OAAO,EAAE,EAAE,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIpD,cAAc,uBAAuB,CAAC;AAItC,OAAO,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,iDAAiD,CAAC;AAC3G,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,iDAAiD,CAAC;AAI7G,cAAc,8CAA8C,CAAC"}