@mo7yw4ng/openape 1.0.0

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

@@ -0,0 +1,7 @@
+import type { Page } from "playwright-core";
+import type { AppConfig, Logger, SessionInfo } from "./types.js";
+/**
+ * Extract Moodle sesskey from the current page.
+ * The sesskey is required for all AJAX calls.
+ */
+export declare function extractSessionInfo(page: Page, config: AppConfig, log: Logger, wsToken?: string): Promise<SessionInfo>;

package/script/src/lib/session.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSessionInfo = void 0;
+const dntShim = __importStar(require("../../_dnt.shims.js"));
+/**
+ * Extract Moodle sesskey from the current page.
+ * The sesskey is required for all AJAX calls.
+ */
+async function extractSessionInfo(page, config, log, wsToken) {
+    // Ensure we're on a Moodle page
+    const url = page.url();
+    if (!url.includes(config.moodleBaseUrl.replace("https://", ""))) {
+        await page.goto(`${config.moodleBaseUrl}/my/`, {
+            waitUntil: "domcontentloaded",
+        });
+    }
+    // Try extracting sesskey from M.cfg (Moodle's JS config object)
+    let sesskey = await page.evaluate(() => {
+        return dntShim.dntGlobalThis.M?.cfg?.sesskey ?? null;
+    });
+    // Fallback: extract from a hidden input
+    if (!sesskey) {
+        sesskey = await page.evaluate(() => {
+            const el = document.querySelector('input[name="sesskey"]');
+            return el?.value ?? null;
+        });
+    }
+    // Fallback: regex on page source
+    if (!sesskey) {
+        const content = await page.content();
+        const match = content.match(/"sesskey"\s*:\s*"([a-zA-Z0-9]+)"/);
+        sesskey = match?.[1] ?? null;
+    }
+    if (!sesskey) {
+        throw new Error("Failed to extract sesskey from Moodle page.");
+    }
+    log.debug(`Extracted sesskey: ${sesskey}`);
+    const sessionInfo = {
+        sesskey,
+        moodleBaseUrl: config.moodleBaseUrl,
+    };
+    if (wsToken) {
+        sessionInfo.wsToken = wsToken;
+        log.debug("Web Service Token included in session");
+    }
+    return sessionInfo;
+}
+exports.extractSessionInfo = extractSessionInfo;

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

@@ -0,0 +1,27 @@
+import type { Page } from "playwright-core";
+import type { AppConfig, Logger } from "./types.js";
+/**
+ * Get the WS token file path from the auth state path.
+ * E.g., .auth/storage-state.json -> .auth/ws-token.json
+ */
+export declare function getWsTokenPath(authStatePath: string): string;
+/**
+ * Load WS token from file if it exists.
+ */
+export declare function loadWsToken(authStatePath: string): string | null;
+/**
+ * Save WS token to file.
+ */
+export declare function saveWsToken(authStatePath: string, token: string): void;
+/**
+ * Acquire Moodle Web Service Token via mobile app launch endpoint.
+ *
+ * Process:
+ * 1. Visit admin/tool/mobile/launch.php with service=moodle_mobile_app
+ * 2. Server redirects to moodlemobile://token=BASE64_DATA (which causes ERR_ABORTED)
+ * 3. We catch the redirect from the response and extract the token
+ *
+ * @returns The Web Service Token for Moodle API calls
+ * @throws Error if token acquisition fails
+ */
+export declare function acquireWsToken(page: Page, config: AppConfig, log: Logger): Promise<string>;

package/script/src/lib/token.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acquireWsToken = exports.saveWsToken = exports.loadWsToken = exports.getWsTokenPath = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Get the WS token file path from the auth state path.
+ * E.g., .auth/storage-state.json -> .auth/ws-token.json
+ */
+function getWsTokenPath(authStatePath) {
+    const dir = path_1.default.dirname(authStatePath);
+    return path_1.default.join(dir, "ws-token.json");
+}
+exports.getWsTokenPath = getWsTokenPath;
+/**
+ * Load WS token from file if it exists.
+ */
+function loadWsToken(authStatePath) {
+    const tokenPath = getWsTokenPath(authStatePath);
+    try {
+        if (fs_1.default.existsSync(tokenPath)) {
+            const content = fs_1.default.readFileSync(tokenPath, "utf8");
+            const data = JSON.parse(content);
+            // Check if token is not too old (Moodle tokens typically expire after some time)
+            if (data.token && data.timestamp) {
+                const age = Date.now() - data.timestamp;
+                // Consider token valid if less than 24 hours old
+                if (age < 24 * 60 * 60 * 1000) {
+                    return data.token;
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore errors, token will be re-acquired
+    }
+    return null;
+}
+exports.loadWsToken = loadWsToken;
+/**
+ * Save WS token to file.
+ */
+function saveWsToken(authStatePath, token) {
+    const tokenPath = getWsTokenPath(authStatePath);
+    try {
+        const data = {
+            token,
+            timestamp: Date.now(),
+        };
+        fs_1.default.writeFileSync(tokenPath, JSON.stringify(data, null, 2));
+    }
+    catch {
+        // Ignore save errors
+    }
+}
+exports.saveWsToken = saveWsToken;
+/**
+ * Extract and decode the Web Service Token from moodlemobile:// URL
+ * Format: moodlemobile://token=BASE64_DATA
+ * Decoded: token:::site_url:::other_params
+ */
+function extractTokenFromCustomScheme(url) {
+    try {
+        const match = url.match(/token=([A-Za-z0-9+/=]+)/);
+        if (!match)
+            return null;
+        // Base64 decode the token data
+        const decoded = atob(match[1]);
+        const parts = decoded.split(":::");
+        // The second part (index 1) is the actual WS token
+        return parts.length >= 2 ? parts[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Acquire Moodle Web Service Token via mobile app launch endpoint.
+ *
+ * Process:
+ * 1. Visit admin/tool/mobile/launch.php with service=moodle_mobile_app
+ * 2. Server redirects to moodlemobile://token=BASE64_DATA (which causes ERR_ABORTED)
+ * 3. We catch the redirect from the response and extract the token
+ *
+ * @returns The Web Service Token for Moodle API calls
+ * @throws Error if token acquisition fails
+ */
+async function acquireWsToken(page, config, log) {
+    log.info("Acquiring Moodle Web Service Token...");
+    // Generate random UUID for passport parameter
+    const passport = crypto.randomUUID();
+    const launchUrl = `${config.moodleBaseUrl}/admin/tool/mobile/launch.php?service=moodle_mobile_app&passport=${passport}`;
+    log.debug(`Token acquisition URL: ${launchUrl}`);
+    // Set up response listener to catch the redirect
+    let tokenFound = false;
+    const tokenPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            if (!tokenFound) {
+                page.off("response", responseHandler);
+                reject(new Error("Token acquisition timed out - no redirect received"));
+            }
+        }, 15000);
+        const responseHandler = async (response) => {
+            try {
+                const status = response.status();
+                const headers = response.headers();
+                // Check for redirect to custom scheme
+                const location = headers["location"] || headers["Location"];
+                if (location && location.startsWith("moodlemobile://")) {
+                    clearTimeout(timeout);
+                    tokenFound = true;
+                    page.off("response", responseHandler);
+                    const token = extractTokenFromCustomScheme(location);
+                    if (token) {
+                        resolve(token);
+                    }
+                    else {
+                        reject(new Error("Failed to extract token from custom scheme URL"));
+                    }
+                }
+            }
+            catch (err) {
+                // Ignore errors in response handler
+            }
+        };
+        page.on("response", responseHandler);
+    });
+    try {
+        // Navigate to the launch endpoint - expect it to fail with ERR_ABORTED
+        // because the browser can't handle moodlemobile:// scheme
+        await page.goto(launchUrl, {
+            waitUntil: "domcontentloaded",
+            timeout: 10000,
+        }).catch(() => {
+            // Expected: navigation will fail due to custom scheme redirect
+            // The token should have been captured by our response handler
+            log.debug("Navigation failed as expected (custom scheme redirect)");
+        });
+        // Wait for the intercepted token
+        const token = await tokenPromise;
+        log.success("Web Service Token acquired successfully");
+        log.debug(`Token (first 10 chars): ${token.substring(0, 10)}...`);
+        return token;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log.warn(`Failed to acquire WS Token: ${message}`);
+        throw error;
+    }
+}
+exports.acquireWsToken = acquireWsToken;

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

@@ -0,0 +1,261 @@
+import type { Page } from "playwright-core";
+export interface AppConfig {
+    courseUrl: string;
+    moodleBaseUrl: string;
+    headless: boolean;
+    slowMo: number;
+    authStatePath: string;
+    ollamaModel?: string;
+    ollamaBaseUrl: string;
+}
+export interface SessionInfo {
+    sesskey: string;
+    moodleBaseUrl: string;
+    wsToken?: string;
+    wsTokenExpires?: number;
+}
+export interface Logger {
+    info: (msg: string) => void;
+    success: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    debug: (msg: string) => void;
+}
+export interface EnrolledCourse {
+    id: number;
+    fullname: string;
+    shortname: string;
+    idnumber?: string;
+    category?: string;
+    progress?: number;
+    startdate?: number;
+    enddate?: number;
+}
+export interface SuperVideoModule {
+    cmid: string;
+    name: string;
+    url: string;
+    isComplete: boolean;
+}
+export interface VideoActivity {
+    name: string;
+    url: string;
+    viewId: number;
+    duration: number;
+    existingPercent: number;
+}
+export interface QuizModule {
+    cmid: string;
+    name: string;
+    url: string;
+    isComplete: boolean;
+    timeOpen?: number;
+    timeClose?: number;
+}
+export interface ForumModule {
+    cmid: string;
+    forumId: number;
+    name: string;
+    url: string;
+    courseId: number;
+    forumType: string;
+}
+export interface ForumPost {
+    id: number;
+    subject: string;
+    author: string;
+    authorId?: number;
+    created: number;
+    modified: number;
+    message: string;
+    discussionId: number;
+    replies?: ForumPost[];
+    unread?: boolean;
+}
+export interface ForumDiscussion {
+    id: number;
+    forumId: number;
+    name: string;
+    firstPostId: number;
+    userId: number;
+    groupId?: number;
+    timedue?: number;
+    timeModified: number;
+    userModified?: number;
+    postCount?: number;
+    unread?: boolean;
+}
+export interface AnnouncementPost {
+    id: number;
+    subject: string;
+    content: string;
+    author: string;
+    authorId?: number;
+    courseId: number;
+    createdAt: number;
+    modifiedAt?: number;
+    attachments?: AnnouncementAttachment[];
+    unread?: boolean;
+}
+export interface AnnouncementAttachment {
+    filename: string;
+    url: string;
+    filesize: number;
+    mimetype: string;
+}
+export interface ResourceModule {
+    cmid: string;
+    name: string;
+    url: string;
+    courseId: number;
+    modType: string;
+    mimetype?: string;
+    filesize?: number;
+    modified?: number;
+}
+export interface FolderContents {
+    files: ResourceFile[];
+    folders: FolderInfo[];
+}
+export interface ResourceFile {
+    filename: string;
+    url: string;
+    filesize: number;
+    mimetype: string;
+    modified: number;
+    path?: string;
+}
+export interface FolderInfo {
+    name: string;
+    id: number;
+    path: string;
+}
+export interface AssignmentModule {
+    cmid: string;
+    name: string;
+    url: string;
+    courseId: number;
+    duedate?: number;
+    cutoffdate?: number;
+    allowSubmissionsFromDate?: number;
+    gradingduedate?: number;
+    submissionStatus?: string;
+    grade?: GradeInfo;
+    lateSubmission?: boolean;
+    extensionduedate?: number;
+}
+export interface AssignmentSubmission {
+    id: number;
+    assignmentId: number;
+    userId: number;
+    timemodified: number;
+    status: string;
+    files?: SubmissionFile[];
+    grade?: GradeInfo;
+    feedback?: string;
+}
+export interface SubmissionFile {
+    filename: string;
+    url: string;
+    filesize: number;
+    mimetype: string;
+    timemodified: number;
+}
+export interface GradeInfo {
+    grade: string;
+    gradeFormatted: string;
+    grader?: string;
+    timedue?: number;
+    timemodified?: number;
+}
+export interface CourseGrade {
+    courseId: number;
+    courseName: string;
+    grade?: string;
+    gradeFormatted?: string;
+    rank?: number;
+    totalUsers?: number;
+    items?: GradeItem[];
+}
+export interface GradeItem {
+    id: number;
+    name: string;
+    grade?: string;
+    gradeFormatted?: string;
+    range?: string;
+    percentage?: number;
+    weight?: number;
+    feedback?: string;
+    graded?: boolean;
+}
+export interface CalendarEvent {
+    id: number;
+    name: string;
+    description?: string;
+    format: number;
+    courseid?: number;
+    categoryid?: number;
+    groupid?: number;
+    userid?: number;
+    moduleid?: number;
+    modulename?: string;
+    instance?: number;
+    eventtype: string;
+    timestart: number;
+    timeduration?: number;
+    timedue?: number;
+    visible?: number;
+    location?: string;
+}
+export interface QuestionParsing {
+    id: string;
+    text: string;
+    options: {
+        value: string;
+        text: string;
+    }[];
+    type: "radio" | "checkbox";
+}
+export interface QuestionAnswer {
+    questionId: string;
+    reasoning: string;
+    answerValues: string[];
+}
+export type OutputFormat = "json" | "csv" | "table" | "silent";
+export interface OutputOptions {
+    format: OutputFormat;
+    fields?: string[];
+    pretty?: boolean;
+}
+export interface ProgressPayload {
+    view_id: number;
+    currenttime: number;
+    duration: number;
+    percent: number;
+    mapa: string;
+}
+export interface AjaxResponse {
+    error: boolean;
+    data?: {
+        success?: boolean;
+        exec?: string;
+    };
+    exception?: {
+        message: string;
+        errorcode: string;
+    };
+}
+export interface CommandContext {
+    page: Page;
+    session: SessionInfo;
+    config: AppConfig;
+    log: Logger;
+}
+export interface CommandOptions {
+    output?: OutputFormat;
+    courseUrl?: string;
+    courseId?: number;
+    verbose?: boolean;
+    headed?: boolean;
+    dryRun?: boolean;
+}

package/script/src/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,5 @@
+/**
+ * Returns the base directory for config/storage resolving.
+ * Handles both Deno (raw/compiled) and Node.js (npx).
+ */
+export declare function getBaseDir(): string;

package/script/src/lib/utils.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseDir = void 0;
+const dntShim = __importStar(require("../../_dnt.shims.js"));
+const path_1 = require("path");
+/**
+ * Returns the base directory for config/storage resolving.
+ * Handles both Deno (raw/compiled) and Node.js (npx).
+ */
+function getBaseDir() {
+    // @ts-ignore - Deno global is available in Deno
+    if (typeof dntShim.Deno !== "undefined" && typeof dntShim.Deno.execPath === "function") {
+        // @ts-ignore
+        const exeDir = (0, path_1.dirname)(dntShim.Deno.execPath());
+        return exeDir.includes("deno") ? process.cwd() : exeDir;
+    }
+    // Node.js or dnt runtime
+    return process.cwd();
+}
+exports.getBaseDir = getBaseDir;