open-vtop 1.0.0

package/dist/session-manager.js

@@ -0,0 +1,588 @@
+/**
+ * Session Manager for VTOP
+ * Automatically initializes and maintains VTOP session cookies and CSRF tokens
+ */
+import { solve, extractDataUriParts, saveCaptchaImage, } from "./captcha-solver.js";
+import * as path from "path";
+const BASE = "https://vtop.vit.ac.in";
+const VTOP = `${BASE}/vtop/`;
+const OPEN_PAGE = `${BASE}/vtop/openPage`;
+const OPEN_PAGE_ALT = `${BASE}/vtop/open/page`;
+const PRELOGIN_SETUP = `${BASE}/vtop/prelogin/setup`;
+const LOGIN_PAGE = `${BASE}/vtop/login`;
+// Post-login endpoints
+const INIT_PAGE = `${BASE}/vtop/init/page`;
+const MAIN_PAGE = `${BASE}/vtop/main/page`;
+const VTOP_OPEN = `${BASE}/vtop/open`;
+const CONTENT = `${BASE}/vtop/content`;
+const ACADEMICS_CHECK = `${BASE}/vtop/academics/common/AcademicsDefaultCheck`;
+const UPCOMING_ASSIGNMENTS = `${BASE}/vtop/get/upcoming/digital/assignments`;
+class VTOPSessionManager {
+    state = {
+        cookies: new Map(),
+        csrf: null,
+        initialized: false,
+        lastInitialized: null,
+        loggedIn: false,
+        username: null,
+        regNo: null,
+    };
+    /**
+     * Extract CSRF token from HTML response
+     */
+    extractCsrf(html) {
+        // Look for _csrf token in various forms
+        const patterns = [
+            /name="_csrf"\s+value="([^"]+)"/,
+            /name='_csrf'\s+value='([^']+)'/,
+            /<input[^>]*name="_csrf"[^>]*value="([^"]+)"/,
+            /<input[^>]*value="([^"]+)"[^>]*name="_csrf"/,
+        ];
+        for (const pattern of patterns) {
+            const match = html.match(pattern);
+            if (match && match[1]) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+    /**
+     * Parse Set-Cookie headers and store cookies
+     */
+    storeCookies(response) {
+        const setCookieHeaders = response.headers.getSetCookie?.() || [];
+        for (const cookieStr of setCookieHeaders) {
+            const [nameValue] = cookieStr.split(";");
+            const [name, value] = nameValue.split("=");
+            if (name && value) {
+                this.state.cookies.set(name.trim(), value.trim());
+            }
+        }
+    }
+    /**
+     * Get cookie header string for requests
+     */
+    getCookieHeader() {
+        return Array.from(this.state.cookies.entries())
+            .map(([name, value]) => `${name}=${value}`)
+            .join("; ");
+    }
+    /**
+     * Make a fetch request with cookie handling
+     */
+    async fetchWithCookies(url, options = {}) {
+        const cookieHeader = this.getCookieHeader();
+        const headers = new Headers(options.headers);
+        if (cookieHeader) {
+            headers.set("Cookie", cookieHeader);
+        }
+        // Add common browser headers
+        headers.set("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36");
+        headers.set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8");
+        headers.set("Accept-Language", "en-US,en;q=0.9");
+        headers.set("Accept-Encoding", "gzip, deflate, br");
+        headers.set("Connection", "keep-alive");
+        headers.set("Upgrade-Insecure-Requests", "1");
+        const response = await fetch(url, {
+            ...options,
+            headers,
+            redirect: "manual", // Handle redirects manually to capture cookies
+        });
+        // Store any cookies from the response
+        this.storeCookies(response);
+        // Follow redirects manually if needed
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get("Location");
+            if (location) {
+                const redirectUrl = location.startsWith("http")
+                    ? location
+                    : new URL(location, url).toString();
+                // Create new options without body for GET redirect
+                const redirectOptions = {
+                    headers: options.headers,
+                    redirect: options.redirect,
+                };
+                return this.fetchWithCookies(redirectUrl, redirectOptions);
+            }
+        }
+        return response;
+    }
+    /**
+     * Initialize VTOP session
+     */
+    async initialize() {
+        try {
+            console.log("🔄 Initializing VTOP session...");
+            // Step 1: GET / to get SERVERID cookie
+            console.log("Step 1: GET / to get SERVERID...");
+            await this.fetchWithCookies(BASE);
+            console.log(" ✓ OK");
+            // Step 2: GET /vtop/ to get JSESSIONID cookie
+            console.log("Step 2: GET /vtop/ to get JSESSIONID...");
+            await this.fetchWithCookies(VTOP);
+            console.log(" ✓ OK");
+            // Step 3: GET /vtop/openPage for CSRF token
+            console.log("Step 3: GET /vtop/openPage for CSRF...");
+            const openPageRes = await this.fetchWithCookies(OPEN_PAGE);
+            const openPageHtml = await openPageRes.text();
+            console.log(" ✓ OK");
+            const csrf = this.extractCsrf(openPageHtml);
+            if (!csrf) {
+                console.warn("⚠️  Warning: _csrf not found on /vtop/openPage. Continuing anyway...");
+            }
+            else {
+                this.state.csrf = csrf;
+                console.log(` ✓ Found _csrf: ${csrf.substring(0, 20)}...`);
+            }
+            // Optional: Visit alternate open page (used as Referer in browser)
+            await this.fetchWithCookies(OPEN_PAGE_ALT).catch(() => {
+                // Ignore errors on this optional step
+            });
+            // Step 4: POST /vtop/prelogin/setup
+            console.log("Step 4: POST /vtop/prelogin/setup (flag=VTOP)...");
+            const formData = new URLSearchParams();
+            if (csrf) {
+                formData.set("_csrf", csrf);
+            }
+            formData.set("flag", "VTOP");
+            const preloginRes = await this.fetchWithCookies(PRELOGIN_SETUP, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    Referer: OPEN_PAGE,
+                    Origin: BASE,
+                },
+                body: formData.toString(),
+            });
+            console.log(` ✓ Prelogin status: ${preloginRes.status}`);
+            // Mark as initialized
+            this.state.initialized = true;
+            this.state.lastInitialized = new Date();
+            console.log("✅ VTOP session initialized successfully!");
+            console.log(`   Cookies stored: ${this.state.cookies.size}`);
+            console.log(`   Cookie names: ${Array.from(this.state.cookies.keys()).join(", ")}`);
+        }
+        catch (error) {
+            console.error("❌ Failed to initialize VTOP session:", error);
+            throw error;
+        }
+    }
+    /**
+     * Get current session state
+     */
+    getState() {
+        return {
+            ...this.state,
+            cookies: new Map(this.state.cookies),
+        };
+    }
+    /**
+     * Get CSRF token
+     */
+    getCsrf() {
+        return this.state.csrf;
+    }
+    /**
+     * Get cookies as a header string
+     */
+    getCookies() {
+        return this.getCookieHeader();
+    }
+    /**
+     * Check if session is initialized
+     */
+    isInitialized() {
+        return this.state.initialized;
+    }
+    /**
+     * Re-initialize session (useful for periodic refresh)
+     */
+    async refresh() {
+        console.log("🔄 Refreshing VTOP session...");
+        this.state.cookies.clear();
+        this.state.csrf = null;
+        this.state.initialized = false;
+        this.state.loggedIn = false;
+        this.state.username = null;
+        await this.initialize();
+    }
+    /**
+     * Detect captcha type from login page HTML using regex (no cheerio)
+     */
+    detectCaptcha(html) {
+        // reCAPTCHA signals
+        const recaptchaDom = html.includes('id="recaptcha"') ||
+            html.includes('id="g-recaptcha"') ||
+            html.includes('class="g-recaptcha"');
+        const recaptchaJs = html.includes("var captchaType=2");
+        const isRecaptcha = recaptchaDom || recaptchaJs;
+        // Text CAPTCHA signals - check for captchaStr input
+        const hasCaptchaInput = html.includes('name="captchaStr"') || html.includes('id="captchaStr"');
+        // Look for data URI image in the HTML
+        // Support both single and double quotes
+        // VTOP sometimes sends "null" in base64, so we need to find the first valid one
+        const imgDataUriMatches = [
+            ...html.matchAll(/src=["'](data:image\/[^"']+)["']/gi),
+        ];
+        let imgDataUri = null;
+        for (const match of imgDataUriMatches) {
+            if (match[1] && !match[1].includes(";base64,null")) {
+                imgDataUri = match[1];
+                break;
+            }
+        }
+        // specific check for the warning if we found matches but none were valid
+        if (!imgDataUri && imgDataUriMatches.length > 0) {
+            console.warn("⚠️ Detected invalid captcha image (base64 is null)");
+        }
+        const isTextCaptcha = hasCaptchaInput && imgDataUri !== null;
+        // Extract CSRF token
+        const csrf = this.extractCsrf(html);
+        return { isTextCaptcha, isRecaptcha, csrf, imgDataUri };
+    }
+    /**
+     * Login to VTOP with username, password, and registration number
+     * Polls the login page until a text CAPTCHA appears, solves it, and submits
+     */
+    async login(username, password, regNo, maxAttempts = 10) {
+        if (!this.state.initialized) {
+            console.log("Session not initialized, initializing first...");
+            await this.initialize();
+        }
+        console.log("🔐 Starting VTOP login process...");
+        console.log("Polling /vtop/login until text CAPTCHA appears...");
+        let attempt = 0;
+        while (attempt < maxAttempts) {
+            attempt++;
+            try {
+                // Fetch login page
+                const res = await this.fetchWithCookies(LOGIN_PAGE);
+                const body = await res.text();
+                const { isTextCaptcha, isRecaptcha, csrf, imgDataUri } = this.detectCaptcha(body);
+                // Get current cookies for logging
+                const curJsession = this.state.cookies.get("JSESSIONID") || "(?)";
+                const curServerID = this.state.cookies.get("SERVERID") || "(?)";
+                console.log(`Attempt ${attempt}: status ${res.status} | text-captcha=${isTextCaptcha ? "YES" : "no"} | recaptcha=${isRecaptcha ? "YES" : "no"} | JSESSIONID=${curJsession}`);
+                if (isTextCaptcha) {
+                    let solvedCaptcha = "";
+                    if (imgDataUri) {
+                        const parts = extractDataUriParts(imgDataUri);
+                        try {
+                            // Trim whitespace just in case
+                            const cleanDataUri = imgDataUri.trim();
+                            if (cleanDataUri !== imgDataUri) {
+                                console.log("⚠️ Trimmed whitespace from captcha data URI");
+                            }
+                            solvedCaptcha = await solve(cleanDataUri);
+                            console.log("✅ Solved CAPTCHA:", solvedCaptcha);
+                            // Save captcha image for debugging
+                            if (parts?.base64) {
+                                const out = path.resolve(process.cwd(), "captcha.jpg");
+                                await saveCaptchaImage(parts.base64, out);
+                                //  console.log(`📷 Saved CAPTCHA image to ${out}`);
+                            }
+                        }
+                        catch (e) {
+                            console.warn("⚠️ Failed to solve captcha:", e);
+                            solvedCaptcha = "";
+                            // Save the failed data URI for inspection
+                            try {
+                                const fs = await import("fs/promises");
+                                const failPath = path.resolve(process.cwd(), "failed_captcha_data.txt");
+                                await fs.writeFile(failPath, imgDataUri);
+                                console.log(`📝 Saved failed captcha data URI to ${failPath}`);
+                            }
+                            catch (writeErr) {
+                                console.error("Failed to save failed captcha data:", writeErr);
+                            }
+                        }
+                    }
+                    else {
+                        console.log("Text CAPTCHA detected but no data URI image found.");
+                    }
+                    // Build and submit login form
+                    console.log("\n📤 Submitting POST /vtop/login ...");
+                    const loginForm = new URLSearchParams();
+                    if (csrf)
+                        loginForm.set("_csrf", csrf);
+                    loginForm.set("username", username);
+                    loginForm.set("password", password);
+                    loginForm.set("captchaStr", solvedCaptcha);
+                    const _cookies = `JSESSIONID=${curJsession}; SERVERID=${curServerID}`;
+                    const postHeaders = {
+                        "Cache-Control": "max-age=0",
+                        Origin: BASE,
+                        Referer: OPEN_PAGE_ALT,
+                        "Content-Type": "application/x-www-form-urlencoded",
+                        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+                        "Accept-Encoding": "gzip, deflate, br, zstd",
+                        "Accept-Language": "en-US,en;q=0.9",
+                        "Sec-Fetch-Dest": "document",
+                        "Sec-Fetch-Mode": "navigate",
+                        "Sec-Fetch-Site": "same-origin",
+                        "Sec-Fetch-User": "?1",
+                        "Upgrade-Insecure-Requests": "1",
+                        Priority: "u=0, i",
+                        Cookie: _cookies,
+                    };
+                    try {
+                        const postRes = await fetch(LOGIN_PAGE, {
+                            method: "POST",
+                            headers: postHeaders,
+                            body: loginForm.toString(),
+                            redirect: "manual",
+                        });
+                        console.log(` -> Login POST status: ${postRes.status}`);
+                        // Store any new cookies
+                        this.storeCookies(postRes);
+                        const setCookie = postRes.headers.getSetCookie?.() || [];
+                        if (setCookie.length > 0) {
+                            console.log(" -> New cookies received");
+                        }
+                        // Check for redirect
+                        const location = postRes.headers.get("Location");
+                        if (location) {
+                            console.log(` -> Redirect to: ${location}`);
+                            // Follow redirect to complete the login flow
+                            const redirectUrl = location.startsWith("http")
+                                ? location
+                                : new URL(location, LOGIN_PAGE).toString();
+                            await this.fetchWithCookies(redirectUrl);
+                        }
+                        // After successfully submitting the captcha, assume login worked
+                        // The actual success will be determined when we try to fetch data
+                        console.log("🎉 Login POST submitted successfully!");
+                        this.state.loggedIn = true;
+                        this.state.username = username;
+                        this.state.regNo = regNo;
+                        return true;
+                    }
+                    catch (e) {
+                        console.error("Login POST failed:", e);
+                    }
+                }
+                // If reCAPTCHA, we cannot solve it automatically
+                if (isRecaptcha) {
+                    console.log("⚠️ reCAPTCHA detected - cannot solve automatically");
+                    // Wait a bit and retry, hoping for text captcha
+                    await new Promise((r) => setTimeout(r, 2000));
+                    continue;
+                }
+                // Wait before next poll
+                await new Promise((r) => setTimeout(r, 500));
+            }
+            catch (e) {
+                console.error(`Attempt ${attempt} failed:`, e);
+                await new Promise((r) => setTimeout(r, 1000));
+            }
+        }
+        console.log(`❌ Login failed after ${maxAttempts} attempts`);
+        return false;
+    }
+    /**
+     * Check if logged in
+     */
+    isLoggedIn() {
+        return this.state.loggedIn;
+    }
+    /**
+     * Get current username
+     */
+    getUsername() {
+        return this.state.username;
+    }
+    /**
+     * Navigate through post-login pages to establish authenticated session
+     * This mimics what the browser does after successful login
+     */
+    async navigatePostLogin() {
+        if (!this.state.loggedIn) {
+            console.error("❌ Cannot navigate post-login pages: not logged in");
+            return false;
+        }
+        const cookies = this.getCookieHeader();
+        const headers = {
+            Referer: LOGIN_PAGE,
+            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
+            Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Cache-Control": "max-age=0",
+            "Upgrade-Insecure-Requests": "1",
+            Origin: BASE,
+            "Content-Type": "application/x-www-form-urlencoded",
+            Cookie: cookies,
+        };
+        try {
+            // Navigate through required pages
+            console.log("📄 Navigating post-login pages...");
+            // 1. /vtop/init/page
+            const initRes = await this.fetchWithCookies(INIT_PAGE, { headers });
+            console.log(` -> /vtop/init/page: ${initRes.status}`);
+            // 2. /vtop/main/page
+            const mainRes = await this.fetchWithCookies(MAIN_PAGE, { headers });
+            console.log(` -> /vtop/main/page: ${mainRes.status}`);
+            // 3. /vtop/open
+            const openRes = await this.fetchWithCookies(VTOP_OPEN, { headers });
+            console.log(` -> /vtop/open: ${openRes.status}`);
+            // 4. /vtop/content - extract new CSRF from here
+            const contentRes = await this.fetchWithCookies(CONTENT, { headers });
+            const contentHtml = await contentRes.text();
+            console.log(` -> /vtop/content: ${contentRes.status}`);
+            const newCsrf = this.extractCsrf(contentHtml);
+            if (newCsrf) {
+                this.state.csrf = newCsrf;
+                console.log(` ✓ Updated CSRF token from content page`);
+            }
+            console.log("✅ Post-login navigation complete");
+            return true;
+        }
+        catch (e) {
+            console.error("❌ Post-login navigation failed:", e);
+            return false;
+        }
+    }
+    /**
+     * Parse upcoming assignments from VTOP HTML response
+     * Uses regex instead of cheerio
+     */
+    parseAssignmentsHtml(html) {
+        const assignments = [];
+        // VTOP returns assignments in a table or as JSON-like structure
+        // Try to parse as JSON first (some endpoints return JSON)
+        try {
+            const jsonMatch = html.match(/\[[\s\S]*?\]/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                if (Array.isArray(parsed)) {
+                    return parsed.map((item) => ({
+                        courseCode: String(item.courseCode || item.code || ""),
+                        courseName: String(item.courseName || item.name || ""),
+                        assignmentTitle: String(item.assignmentTitle || item.title || item.assignmentName || ""),
+                        dueDate: String(item.dueDate || item.endDate || item.deadline || ""),
+                        status: String(item.status || ""),
+                        maxMarks: String(item.maxMarks || item.marks || ""),
+                    }));
+                }
+            }
+        }
+        catch {
+            // Not JSON, try HTML parsing
+        }
+        // Parse HTML table rows using regex
+        // VTOP table structure: #(th), Course Name(td), Title(td), Last Date(td), Uploaded(td)
+        // Note: VTOP HTML sometimes has malformed tags like <<td
+        const rowRegex = /<tr[^>]*>([\s\S]*?)<\/tr>/gi;
+        // Match both <th> and <td> cells, and handle malformed <<td
+        const cellRegex = /<?<t[hd][^>]*>([\s\S]*?)(?:<\/t[hd]>|<\/tr|<tr|$)/gi;
+        let rowMatch;
+        while ((rowMatch = rowRegex.exec(html)) !== null) {
+            const cells = [];
+            let cellMatch;
+            const rowContent = rowMatch[1];
+            // Reset lastIndex for cell regex
+            cellRegex.lastIndex = 0;
+            while ((cellMatch = cellRegex.exec(rowContent)) !== null) {
+                // Strip HTML tags from cell content
+                const cellContent = cellMatch[1].replace(/<[^>]+>/g, "").trim();
+                cells.push(cellContent);
+            }
+            // Skip header rows (first cell would be "#" or similar header text)
+            if (cells.length >= 4 && cells[0] !== "#" && !isNaN(Number(cells[0]))) {
+                // Table structure: # (row num), Course Name, Title, Last Date, Uploaded
+                // cells[0] = row number (skip)
+                // cells[1] = Course Name
+                // cells[2] = Title (assignment title)
+                // cells[3] = Last Date (due date)
+                // cells[4] = Uploaded (status)
+                assignments.push({
+                    courseCode: "", // Not in this table format
+                    courseName: cells[1] || "",
+                    assignmentTitle: cells[2] || "",
+                    dueDate: cells[3] || "",
+                    status: cells[4] || "Pending",
+                    maxMarks: "", // Not in this table format
+                });
+            }
+        }
+        return assignments;
+    }
+    /**
+     * Fetch upcoming assignments from VTOP
+     */
+    async fetchUpcomingAssignments() {
+        if (!this.state.loggedIn || !this.state.regNo) {
+            console.error("❌ Cannot fetch assignments: not logged in or no regNo");
+            return [];
+        }
+        // Ensure we've navigated post-login pages
+        await this.navigatePostLogin();
+        const cookies = this.getCookieHeader();
+        const now = new Date();
+        // First, do the academics default check
+        const accParams = new URLSearchParams();
+        accParams.set("authorizedID", this.state.regNo);
+        if (this.state.csrf)
+            accParams.set("_csrf", this.state.csrf);
+        accParams.set("x", now.toUTCString());
+        const apiHeaders = {
+            Accept: "*/*",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": "en-US,en;q=0.7",
+            "Content-Type": "application/x-www-form-urlencoded",
+            Cookie: cookies,
+            Origin: BASE,
+            Priority: "u=1, i",
+            Referer: CONTENT,
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-origin",
+            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36",
+        };
+        try {
+            // AcademicsDefaultCheck
+            console.log("📚 Checking academics context...");
+            const accRes = await fetch(ACADEMICS_CHECK, {
+                method: "POST",
+                headers: apiHeaders,
+                body: accParams.toString(),
+            });
+            console.log(` -> AcademicsDefaultCheck: ${accRes.status}`);
+        }
+        catch (e) {
+            console.warn("⚠️ AcademicsDefaultCheck failed:", e);
+        }
+        // Now fetch the assignments
+        const assParams = new URLSearchParams();
+        assParams.set("authorizedID", this.state.regNo);
+        if (this.state.csrf)
+            assParams.set("_csrf", this.state.csrf);
+        assParams.set("x", now.toUTCString());
+        try {
+            console.log("📝 Fetching upcoming assignments...");
+            const assRes = await fetch(UPCOMING_ASSIGNMENTS, {
+                method: "POST",
+                headers: apiHeaders,
+                body: assParams.toString(),
+            });
+            console.log(` -> Upcoming assignments: ${assRes.status}`);
+            const assBody = await assRes.text();
+            console.log(` -> Response length: ${assBody.length} chars`);
+            console.log(` -> Raw response:\n${assBody}`);
+            if (assBody) {
+                const assignments = this.parseAssignmentsHtml(assBody);
+                console.log(`✅ Parsed ${assignments.length} assignments`);
+                return assignments;
+            }
+        }
+        catch (e) {
+            console.error("❌ Failed to fetch assignments:", e);
+        }
+        return [];
+    }
+}
+// Export singleton instance
+export const sessionManager = new VTOPSessionManager();
+// Auto-initialize on module load
+sessionManager.initialize().catch((error) => {
+    console.error("Failed to auto-initialize session:", error);
+});

package/dist/views/Home.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+import { BaseLayout } from "./layouts/Base.js";
+export const Home = () => {
+    return (_jsxs(BaseLayout, { title: "Open-VTOP", children: [_jsx("h1", { children: "Open-VTOP" }), _jsxs("div", { class: "section", children: [_jsx("h2", { children: "\uD83D\uDD10 Login to VTOP" }), _jsxs("form", { id: "login-form", style: "display: flex; flex-direction: column; gap: 0.75rem; max-width: 400px;", children: [_jsxs("div", { children: [_jsx("label", { for: "username", style: "display: block; margin-bottom: 0.25rem; font-weight: bold;", children: "Username:" }), _jsx("input", { type: "text", id: "username", name: "username", placeholder: "Enter your VTOP username", style: "width: 100%; padding: 0.5rem; border: 1px solid #ccc; border-radius: 4px; font-size: 1rem;", required: true })] }), _jsxs("div", { children: [_jsx("label", { for: "password", style: "display: block; margin-bottom: 0.25rem; font-weight: bold;", children: "Password:" }), _jsx("input", { type: "password", id: "password", name: "password", placeholder: "Enter your password", style: "width: 100%; padding: 0.5rem; border: 1px solid #ccc; border-radius: 4px; font-size: 1rem;", required: true })] }), _jsxs("div", { children: [_jsx("label", { for: "regNo", style: "display: block; margin-bottom: 0.25rem; font-weight: bold;", children: "Registration Number:" }), _jsx("input", { type: "text", id: "regNo", name: "regNo", placeholder: "e.g. 24BCI0150", style: "width: 100%; padding: 0.5rem; border: 1px solid #ccc; border-radius: 4px; font-size: 1rem;", required: true })] }), _jsx("button", { type: "submit", "hx-post": "/api/login/form", "hx-target": "#login-result", "hx-swap": "innerHTML", "hx-include": "#login-form", style: "padding: 0.75rem; background: #4CAF50; color: white; border: none; border-radius: 4px; cursor: pointer; font-size: 1rem; font-weight: bold;", children: "\uD83D\uDE80 Login" })] }), _jsx("div", { id: "login-result", style: "margin-top: 1rem;" })] }), _jsxs("div", { class: "section", children: [_jsx("h2", { children: "\uD83D\uDCCA Login Status" }), _jsx("button", { "hx-get": "/api/login/status/html", "hx-target": "#login-status", "hx-swap": "innerHTML", "hx-trigger": "load, click", children: "Refresh Login Status" }), _jsx("div", { id: "login-status", children: "Loading..." })] }), _jsxs("div", { class: "section", children: [_jsx("h2", { children: "\uD83D\uDCDA Upcoming Assignments" }), _jsx("button", { "hx-get": "/api/assignments/html", "hx-target": "#assignments-list", "hx-swap": "innerHTML", "hx-indicator": "#assignments-loading", style: "background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border: none; color: white; padding: 0.75rem 1.5rem; border-radius: 8px; font-weight: bold; cursor: pointer;", children: "\uD83D\uDD04 Load Assignments" }), _jsx("span", { id: "assignments-loading", class: "htmx-indicator", style: "margin-left: 0.5rem; color: #aaa;", children: "Loading..." }), _jsx("div", { id: "assignments-list", style: "margin-top: 1rem;", children: _jsx("div", { style: "color: #888; padding: 1rem; background: #f5f5f5; border-radius: 8px;", children: "Click \"Load Assignments\" to fetch your upcoming assignments from VTOP." }) })] }), _jsxs("div", { class: "section", children: [_jsx("h2", { children: "\uD83D\uDD27 Session Status" }), _jsx("button", { "hx-get": "/api/session/status", "hx-target": "#session-status", "hx-swap": "innerHTML", "hx-trigger": "load, click", children: "Refresh Session Status" }), _jsx("div", { id: "session-status", children: "Loading session status..." })] }), _jsxs("div", { class: "section", children: [_jsx("h2", { children: "\uD83D\uDCDD Debug Logs" }), _jsx("button", { "hx-get": "/api/debug/logs", "hx-target": "#debug-logs", "hx-swap": "innerHTML", "hx-trigger": "click", children: "Load Debug Logs" }), _jsx("button", { "hx-post": "/api/debug/logs/clear", "hx-target": "#debug-logs", "hx-swap": "innerHTML", style: "margin-left: 0.5rem; background: #ff6b6b;", children: "Clear Logs" }), _jsx("div", { id: "debug-logs", style: "margin-top: 1rem; max-height: 400px; overflow-y: auto; background: #1e1e1e; color: #0f0; font-family: monospace; padding: 1rem; border-radius: 4px; font-size: 0.85rem;", children: "Click \"Load Debug Logs\" to see login attempts..." })] })] }));
+};

package/dist/views/components/Container.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+export const Container = ({ title, children }) => {
+    return (_jsxs("div", { class: "container", children: [_jsx("h2", { children: title }), children] }));
+};

package/dist/views/components/Item.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+export const Item = ({ id, name }) => {
+    return (_jsxs("div", { id: `item-${id}`, class: "item", children: [name, _jsx("button", { "hx-delete": `/api/items/${id}`, "hx-confirm": "Are you sure you want to delete this item?", "hx-target": `#item-${id}`, "hx-swap": "outerHTML", class: "danger", children: "Delete" })] }));
+};