@mo7yw4ng/openape 1.0.0

package/script/src/lib/auth.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeBrowserSafely = exports.launchAuthenticated = exports.findEdgePath = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const playwright_core_1 = require("playwright-core");
+const token_js_1 = require("./token.js");
+/**
+ * Find a Chromium-based browser executable on Windows.
+ * Priority: Edge → Chrome → Brave
+ */
+function findEdgePath() {
+    const roots = [
+        process.env.PROGRAMFILES,
+        process.env["PROGRAMFILES(X86)"],
+        process.env.LOCALAPPDATA,
+    ].filter(Boolean);
+    const browsers = [
+        { name: "Edge", suffix: "Microsoft\\Edge\\Application\\msedge.exe" },
+        { name: "Chrome", suffix: "Google\\Chrome\\Application\\chrome.exe" },
+        { name: "Brave", suffix: "BraveSoftware\\Brave-Browser\\Application\\brave.exe" },
+    ];
+    for (const { suffix } of browsers) {
+        for (const root of roots) {
+            const candidate = path_1.default.join(root, suffix);
+            if (fs_1.default.existsSync(candidate))
+                return candidate;
+        }
+    }
+    throw new Error("找不到可用的瀏覽器（Edge / Chrome / Brave）。請確認已安裝其中一種。");
+}
+exports.findEdgePath = findEdgePath;
+/**
+ * Launch a browser and return an authenticated context.
+ * Tries to restore a saved session first; falls back to fresh OAuth login.
+ * Also acquires Moodle Web Service Token for API calls.
+ */
+async function launchAuthenticated(config, log) {
+    const edgePath = findEdgePath();
+    log.debug(`Using Edge: ${edgePath}`);
+    // Wait a bit to ensure any previous browser process has fully terminated
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    const browser = await playwright_core_1.chromium.launch({
+        executablePath: edgePath,
+        headless: config.headless,
+        slowMo: config.slowMo,
+    });
+    // Try loading saved WS token first
+    let wsToken = (0, token_js_1.loadWsToken)(config.authStatePath) ?? undefined;
+    if (wsToken) {
+        log.info("Loaded saved Web Service Token.");
+    }
+    // Try restoring a saved session
+    const restored = await tryRestoreSession(browser, config, log);
+    if (restored) {
+        const page = restored.pages()[0] ?? (await restored.newPage());
+        // If no saved WS token, try to acquire one
+        if (!wsToken) {
+            try {
+                wsToken = await (0, token_js_1.acquireWsToken)(page, config, log);
+                (0, token_js_1.saveWsToken)(config.authStatePath, wsToken);
+            }
+            catch {
+                log.warn("Failed to acquire WS Token with restored session, continuing without it.");
+            }
+        }
+        return { browser, context: restored, page, wsToken };
+    }
+    // Fresh login
+    if (config.headless) {
+        await browser.close().catch(() => { });
+        throw new Error("找不到有效的 Session 或是 Session 已過期。\n" +
+            "請先執行 `openape login` 進行手動登入，或是加上 `--headed` 參數執行目前的指令以開啟登入畫面。");
+    }
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    await login(page, config, log);
+    await saveSession(context, config.authStatePath, log);
+    // Acquire WS Token after successful login
+    if (!wsToken) {
+        try {
+            wsToken = await (0, token_js_1.acquireWsToken)(page, config, log);
+            (0, token_js_1.saveWsToken)(config.authStatePath, wsToken);
+        }
+        catch {
+            log.warn("Failed to acquire WS Token, continuing with sesskey-only auth.");
+        }
+    }
+    return { browser, context, page, wsToken };
+}
+exports.launchAuthenticated = launchAuthenticated;
+/**
+ * Safely close browser and context with timeout.
+ * Designed for AI agent usage - no human interaction needed.
+ * If noWait is true, initiates cleanup but doesn't wait for completion.
+ */
+async function closeBrowserSafely(browser, context, timeoutMs = 5000, noWait = false) {
+    const closePromises = [];
+    // Close context with error handling
+    if (context) {
+        closePromises.push(Promise.race([
+            context.close().catch(() => { }),
+            new Promise(resolve => setTimeout(() => resolve(), timeoutMs))
+        ]));
+    }
+    // Close browser with error handling
+    closePromises.push(Promise.race([
+        browser.close().catch(() => { }),
+        new Promise(resolve => setTimeout(() => resolve(), timeoutMs))
+    ]));
+    if (noWait) {
+        // Fire and forget - don't wait for cleanup
+        Promise.allSettled(closePromises);
+        return;
+    }
+    await Promise.allSettled(closePromises);
+}
+exports.closeBrowserSafely = closeBrowserSafely;
+/**
+ * Attempt to restore a session from stored state.
+ * Returns null if the stored state doesn't exist or the session is expired.
+ */
+async function tryRestoreSession(browser, config, log) {
+    const statePath = path_1.default.resolve(config.authStatePath);
+    if (!fs_1.default.existsSync(statePath)) {
+        log.debug("No saved session found, will perform fresh login.");
+        return null;
+    }
+    log.info("Restoring saved session...");
+    const context = await browser.newContext({ storageState: statePath });
+    const page = await context.newPage();
+    try {
+        await page.goto(`${config.moodleBaseUrl}/my/`, {
+            waitUntil: "domcontentloaded",
+            timeout: 15000,
+        });
+        // If we got redirected to a login page, the session is expired
+        const url = page.url();
+        if (url.includes("login") || url.includes("microsoftonline")) {
+            log.warn("Saved session expired, will re-authenticate.");
+            await context.close();
+            return null;
+        }
+        log.success("Session restored successfully.");
+        return context;
+    }
+    catch {
+        log.warn("Failed to restore session, will re-authenticate.");
+        await context.close();
+        return null;
+    }
+}
+/**
+ * Save the current session state to disk for future reuse.
+ */
+async function saveSession(context, statePath, log) {
+    try {
+        await context.storageState({ path: statePath });
+        log.debug("Session saved for future reuse.");
+    }
+    catch (err) {
+        log.warn(`Failed to save session: ${err}`);
+    }
+}
+/**
+ * Perform Microsoft OAuth login flow.
+ */
+async function login(page, config, log) {
+    log.info("Starting Microsoft OAuth login...");
+    await page.goto(`${config.moodleBaseUrl}/auth/oauth2/login.php`, {
+        waitUntil: "domcontentloaded",
+        timeout: 30000,
+    });
+    // Wait for Microsoft login page or redirect back to Moodle
+    try {
+        await page.waitForURL((url) => url.toString().includes("microsoftonline") ||
+            url.toString().includes("login.microsoftonline") ||
+            (url.toString().includes("ilearning.cycu.edu.tw") &&
+                !url.toString().includes("auth/oauth2/login")), { timeout: 10000 });
+        const url = page.url().toString();
+        if (url.includes("microsoftonline") || url.includes("login.microsoftonline")) {
+            log.info("Microsoft login page detected. Please complete login in the browser.");
+            log.info("Waiting for redirect back to Moodle...");
+            await page.waitForURL((u) => u.toString().includes("ilearning.cycu.edu.tw") &&
+                !u.toString().includes("microsoftonline") &&
+                !u.toString().includes("login.microsoftonline"), { timeout: 300000 });
+        }
+    }
+    catch {
+        // Already logged in or redirected
+    }
+    // Verify we're logged in
+    const finalUrl = page.url().toString();
+    if (finalUrl.includes("login") ||
+        finalUrl.includes("microsoftonline") ||
+        finalUrl === config.moodleBaseUrl + "/auth/oauth2/login.php") {
+        throw new Error(`登入後未重新導向回 Moodle。目前 URL: ${finalUrl}`);
+    }
+    log.success("Login completed successfully.");
+}

package/script/src/lib/config.d.ts

@@ -0,0 +1,5 @@
+import type { AppConfig } from "./types.js";
+/**
+ * Load config from .env file (if it exists).
+ */
+export declare function loadConfig(baseDir?: string): AppConfig;

package/script/src/lib/config.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Load config from .env file (if it exists).
+ */
+function loadConfig(baseDir) {
+    const envPath = baseDir ? path_1.default.resolve(baseDir, ".env") : path_1.default.resolve(".env");
+    if (fs_1.default.existsSync(envPath)) {
+        const envContent = fs_1.default.readFileSync(envPath, "utf8");
+        for (const line of envContent.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx === -1)
+                continue;
+            const key = trimmed.slice(0, eqIdx).trim();
+            const value = trimmed.slice(eqIdx + 1).trim();
+            if (!process.env[key])
+                process.env[key] = value;
+        }
+    }
+    return buildConfig();
+}
+exports.loadConfig = loadConfig;
+function buildConfig() {
+    const moodleBaseUrl = (process.env.MOODLE_BASE_URL ?? "https://ilearning.cycu.edu.tw").replace(/\/$/, "");
+    return {
+        courseUrl: "",
+        moodleBaseUrl,
+        headless: process.env.HEADLESS !== "false",
+        slowMo: parseInt(process.env.SLOW_MO ?? "0", 10),
+        authStatePath: process.env.AUTH_STATE_PATH ?? ".auth/storage-state.json",
+        ollamaModel: process.env.MODEL,
+        ollamaBaseUrl: (process.env.OLLAMA_BASE_URL ?? "http://localhost:11434").replace(/\/$/, ""),
+    };
+}

package/script/src/lib/logger.d.ts

@@ -0,0 +1,2 @@
+import type { Logger } from "./types.js";
+export declare function createLogger(verbose?: boolean, silent?: boolean): Logger;

package/script/src/lib/logger.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = void 0;
+const NO_COLOR = !!process.env.NO_COLOR;
+const c = (code, text) => NO_COLOR ? text : `\x1b[${code}m${text}\x1b[0m`;
+function createLogger(verbose = false, silent = false) {
+    if (silent) {
+        // Silent logger - no output at all
+        return {
+            info: (_msg) => { },
+            success: (_msg) => { },
+            warn: (_msg) => { },
+            error: (_msg) => { },
+            debug: (_msg) => { },
+        };
+    }
+    return {
+        info: (msg) => console.error(c("36", "[INFO]") + `  ${msg}`),
+        success: (msg) => console.error(c("32", "[OK]") + `    ${msg}`),
+        warn: (msg) => console.error(c("33", "[WARN]") + `  ${msg}`),
+        error: (msg) => console.error(c("31", "[ERR]") + `   ${msg}`),
+        debug: (msg) => {
+            if (verbose)
+                console.error(c("90", "[DBG]") + `   ${msg}`);
+        },
+    };
+}
+exports.createLogger = createLogger;

package/script/src/lib/moodle.d.ts

@@ -0,0 +1,234 @@
+import type { Page } from "playwright-core";
+import type { SessionInfo, Logger, EnrolledCourse, SuperVideoModule, QuizModule, ForumModule, ResourceModule, ForumDiscussion, ForumPost, CalendarEvent, CourseGrade } from "./types.js";
+/**
+ * Direct HTTP API call without browser (for WS API only).
+ * This is much faster than browser-based calls.
+ */
+export declare function moodleApiCall<T = unknown>(session: {
+    wsToken: string;
+    moodleBaseUrl: string;
+}, methodname: string, args: Record<string, unknown>): Promise<T>;
+/**
+ * Send a Moodle AJAX request and return the result.
+ * Uses Web Service token if available AND the function is in WS_API_FUNCTIONS,
+ * otherwise falls back to sesskey-based AJAX (via /lib/ajax/service.php).
+ */
+export declare function moodleAjax<T = unknown>(page: Page, session: SessionInfo, methodname: string, args: Record<string, unknown>): Promise<T>;
+/**
+ * Fetch enrolled courses via pure API (no browser required).
+ * Fast and lightweight - uses HTTP fetch directly.
+ */
+export declare function getEnrolledCoursesApi(session: {
+    wsToken: string;
+    moodleBaseUrl: string;
+}, options?: {
+    classification?: "inprogress" | "past" | "future" | "all";
+    limit?: number;
+}): Promise<EnrolledCourse[]>;
+/**
+ * Fetch all enrolled courses via Moodle AJAX API.
+ */
+export declare function getEnrolledCourses(page: Page, session: SessionInfo, log: Logger, options?: {
+    classification?: "inprogress" | "past" | "future";
+    limit?: number;
+}): Promise<EnrolledCourse[]>;
+/**
+ * Get course state (modules) via core_courseformat_get_state.
+ */
+export declare function getCourseState(page: Page, session: SessionInfo, courseId: number): Promise<any>;
+/**
+ * Get all SuperVideo modules in a course.
+ */
+export declare function getSupervideosInCourse(page: Page, session: SessionInfo, courseId: number, log: Logger, options?: {
+    incompleteOnly?: boolean;
+}): Promise<SuperVideoModule[]>;
+/**
+ * Get all Quiz modules in a course.
+ */
+export declare function getQuizzesInCourse(page: Page, session: SessionInfo, courseId: number, log: Logger): Promise<QuizModule[]>;
+/**
+ * Get all forum modules in a course.
+ * If WS token is available, fetches forum IDs directly via WS API.
+ */
+export declare function getForumsInCourse(page: Page, session: SessionInfo, courseId: number, log: Logger): Promise<ForumModule[]>;
+/**
+ * Get all forums via pure WS API (no browser required).
+ * Fast and lightweight - uses HTTP fetch directly.
+ */
+export declare function getForumsApi(session: {
+    wsToken: string;
+    moodleBaseUrl: string;
+}, courseIds: number[]): Promise<Array<{
+    id: number;
+    cmid: number;
+    name: string;
+    courseid: number;
+}>>;
+/**
+ * Extract forum ID from forum page.
+ * First tries to find it in embedded page data, then falls back to
+ * extracting it from discussion posts API.
+ */
+export declare function getForumIdFromPage(page: Page, cmid: number, session?: SessionInfo): Promise<number | null>;
+/**
+ * Get forums by course IDs via AJAX.
+ * Returns forum instance IDs directly from Moodle API.
+ * This is the cleanest way to get forum instance IDs.
+ */
+export declare function getForumsByCourseIds(page: Page, session: SessionInfo, courseIds: number[]): Promise<Array<{
+    id: number;
+    course: number;
+    name: string;
+}>>;
+/**
+ * Get discussions in a forum via AJAX.
+ * Note: Requires forum instance ID, not cmid. Use getForumsByCourseIds() first.
+ */
+export declare function getForumDiscussions(page: Page, session: SessionInfo, forumId: number): Promise<ForumDiscussion[]>;
+/**
+ * Get posts in a discussion via AJAX.
+ */
+export declare function getDiscussionPosts(page: Page, session: SessionInfo, discussionId: number): Promise<ForumPost[]>;
+/**
+ * Get all resource modules in a course.
+ */
+export declare function getResourcesInCourse(page: Page, session: SessionInfo, courseId: number, log: Logger): Promise<ResourceModule[]>;
+/**
+ * Get course grades for the current user via AJAX.
+ */
+export declare function getCourseGrades(page: Page, session: SessionInfo, courseId: number): Promise<CourseGrade>;
+/**
+ * Get course grades for the current user via pure WS API (no browser required).
+ * Fast and lightweight - uses HTTP fetch directly.
+ */
+export declare function getCourseGradesApi(session: {
+    wsToken: string;
+    moodleBaseUrl: string;
+}, courseId: number): Promise<CourseGrade>;
+/**
+ * Get calendar events via AJAX.
+ */
+export declare function getCalendarEvents(page: Page, session: SessionInfo, options?: {
+    courseId?: number;
+    startTime?: number;
+    endTime?: number;
+    events?: {
+        courseid?: number;
+        groupid?: number;
+        categoryid?: number;
+    }[];
+}): Promise<CalendarEvent[]>;
+/**
+ * Get calendar events via pure WS API (no browser required).
+ * Fast and lightweight - uses HTTP fetch directly.
+ */
+export declare function getCalendarEventsApi(session: {
+    wsToken: string;
+    moodleBaseUrl: string;
+}, options?: {
+    courseId?: number;
+    startTime?: number;
+    endTime?: number;
+    events?: {
+        courseid?: number;
+        groupid?: number;
+        categoryid?: number;
+    }[];
+}): Promise<CalendarEvent[]>;
+/**
+ * Visit a SuperVideo activity page and extract view_id + duration.
+ */
+export declare function getVideoMetadata(page: Page, activityUrl: string, log: Logger): Promise<{
+    name: string;
+    url: string;
+    viewId: number;
+    duration: number;
+    existingPercent: number;
+    videoSources: string[];
+    youtubeIds?: string[];
+}>;
+/**
+ * Download a video from SuperVideo activity.
+ * Supports direct video URLs (pluginfile.php) and YouTube videos.
+ */
+export declare function downloadVideo(page: Page, metadata: {
+    name: string;
+    videoSources: string[];
+    youtubeIds?: string[];
+}, outputPath: string, log: Logger): Promise<{
+    success: boolean;
+    path?: string;
+    error?: string;
+    type?: string;
+}>;
+/**
+ * Complete a video by forging progress AJAX call.
+ */
+export declare function completeVideo(page: Page, session: SessionInfo, video: {
+    viewId: number;
+    duration: number;
+    url: string;
+    cmid?: string;
+}, log: Logger): Promise<boolean>;
+/**
+ * Get site info including current user ID via pure WS API.
+ */
+export declare function getSiteInfoApi(session: {
+    wsToken: string;
+    moodleBaseUrl: string;
+}): Promise<{
+    userid: number;
+    username: string;
+    fullname: string;
+    sitename: string;
+}>;
+/**
+ * Get course contents and filter for SuperVideo modules via pure WS API.
+ */
+export declare function getSupervideosInCourseApi(session: {
+    wsToken: string;
+    moodleBaseUrl: string;
+}, courseId: number): Promise<SuperVideoModule[]>;
+/**
+ * Extended QuizModule with courseId for API responses.
+ */
+export interface QuizModuleWithCourse extends QuizModule {
+    courseId: number;
+}
+/**
+ * Get quizzes in courses via pure WS API.
+ */
+export declare function getQuizzesByCoursesApi(session: {
+    wsToken: string;
+    moodleBaseUrl: string;
+}, courseIds: number[]): Promise<QuizModuleWithCourse[]>;
+/**
+ * Get resources in courses via pure WS API.
+ */
+export declare function getResourcesByCoursesApi(session: {
+    wsToken: string;
+    moodleBaseUrl: string;
+}, courseIds: number[]): Promise<ResourceModule[]>;
+export interface Message {
+    id: number;
+    useridfrom: number;
+    useridto: number;
+    subject: string;
+    text: string;
+    timecreated: number;
+    fullmessage: string;
+    fullmessageformat: number;
+    fullmessagehtml: string;
+}
+/**
+ * Get messages for the current user via pure WS API.
+ */
+export declare function getMessagesApi(session: {
+    wsToken: string;
+    moodleBaseUrl: string;
+}, userIdTo: number, options?: {
+    useridfrom?: number;
+    read?: boolean;
+    limitfrom?: number;
+    limitnum?: number;
+}): Promise<Message[]>;