@mo7yw4ng/openape 1.0.0

package/script/src/commands/skills.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSkillsCommand = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const SKILL_NAME = "openape";
+const GITHUB_RAW_URL = `https://raw.githubusercontent.com/mo7yw4ng/openape/refs/heads/main/skills/${SKILL_NAME}/SKILL.md`;
+/**
+ * Known agent platforms and their skills directories
+ */
+const PLATFORMS = {
+    claude: { name: "Claude Code", path: path_1.default.join(os_1.default.homedir(), ".claude", "skills") },
+    codex: { name: "Codex CLI", path: path_1.default.join(os_1.default.homedir(), ".codex", "skills") },
+    opencode: { name: "OpenCode", path: path_1.default.join(os_1.default.homedir(), ".opencode", "skills") },
+};
+/**
+ * Try to read SKILL.md from local project first (dev mode / bundled build),
+ * fallback to fetching from GitHub (when installed globally via npm).
+ */
+async function readSkillContent() {
+    // Try local path first (relative to this file's location)
+    try {
+        const base = path_1.default.dirname(new URL(require("url").pathToFileURL(__filename).href).pathname);
+        const normalized = process.platform === "win32" ? base.replace(/^\//, "") : base;
+        // When running from source: src/commands/ → ../../skills/openape/SKILL.md
+        // When bundled by dnt into build/: esm/commands/ or script/ → ../../skills/openape/SKILL.md
+        const localPath = path_1.default.resolve(normalized, "..", "..", "skills", SKILL_NAME, "SKILL.md");
+        if (fs_1.default.existsSync(localPath)) {
+            return fs_1.default.readFileSync(localPath, "utf-8");
+        }
+    }
+    catch {
+        // import.meta.url may be unavailable in some environments
+    }
+    // Fallback: fetch from GitHub
+    const res = await fetch(GITHUB_RAW_URL, { headers: { "User-Agent": "openape-cli" } });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch skill from GitHub: ${res.status} ${res.statusText}`);
+    }
+    return res.text();
+}
+function registerSkillsCommand(program) {
+    const skills = program
+        .command("skills")
+        .description("Manage OpenApe skills for AI agents");
+    skills
+        .command("install [platform]")
+        .description("Install the OpenApe skill to an agent platform (claude, codex, opencode)")
+        .option("--all", "Detect installed agents and install to all")
+        .action(async (platform, opts) => {
+        try {
+            let targets = [];
+            if (opts?.all) {
+                for (const [key, info] of Object.entries(PLATFORMS)) {
+                    const parentDir = path_1.default.dirname(info.path);
+                    if (fs_1.default.existsSync(parentDir)) {
+                        targets.push({ key, ...info });
+                    }
+                }
+                if (targets.length === 0) {
+                    console.log("No supported agents detected. Supported platforms: " + Object.keys(PLATFORMS).join(", "));
+                    return;
+                }
+            }
+            else if (platform) {
+                const info = PLATFORMS[platform.toLowerCase()];
+                if (!info) {
+                    console.error(`Unknown platform: ${platform}`);
+                    console.error(`Supported platforms: ${Object.keys(PLATFORMS).join(", ")}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                targets = [{ key: platform.toLowerCase(), ...info }];
+            }
+            else {
+                console.error("Specify a platform or use --all.");
+                console.error(`Example: openape skills install claude`);
+                process.exitCode = 1;
+                return;
+            }
+            console.log(`Fetching ${SKILL_NAME} skill...`);
+            const content = await readSkillContent();
+            for (const target of targets) {
+                console.log(`Installing to ${target.name} (${target.path})...`);
+                const destDir = path_1.default.join(target.path, SKILL_NAME);
+                if (!fs_1.default.existsSync(destDir)) {
+                    fs_1.default.mkdirSync(destDir, { recursive: true });
+                }
+                fs_1.default.writeFileSync(path_1.default.join(destDir, "SKILL.md"), content, "utf-8");
+                console.log(`  \x1b[32m✔\x1b[0m ${SKILL_NAME} installed!`);
+            }
+            console.log("\nDone!");
+        }
+        catch (err) {
+            console.error(`\x1b[31mFailed to install skill: ${err.message}\x1b[0m`);
+            process.exitCode = 1;
+        }
+    });
+    skills
+        .command("show")
+        .description("Print the raw SKILL.md content")
+        .action(async () => {
+        try {
+            const content = await readSkillContent();
+            process.stdout.write(content);
+        }
+        catch (err) {
+            console.error(`\x1b[31mFailed: ${err.message}\x1b[0m`);
+            process.exitCode = 1;
+        }
+    });
+}
+exports.registerSkillsCommand = registerSkillsCommand;

package/script/src/commands/videos.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerVideosCommand(program: Command): void;

package/script/src/commands/videos.js

@@ -0,0 +1,334 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerVideosCommand = void 0;
+const utils_js_1 = require("../lib/utils.js");
+const moodle_js_1 = require("../lib/moodle.js");
+const logger_js_1 = require("../lib/logger.js");
+const auth_js_1 = require("../lib/auth.js");
+const session_js_1 = require("../lib/session.js");
+const auth_js_2 = require("../lib/auth.js");
+const index_js_1 = require("../index.js");
+const token_js_1 = require("../lib/token.js");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function registerVideosCommand(program) {
+    const videosCmd = program.command("videos");
+    videosCmd.description("Video progress operations");
+    // Helper to get output format from global or local options
+    function getOutputFormat(command) {
+        const opts = command.optsWithGlobals();
+        return opts.output || "json";
+    }
+    // Pure API context - no browser required (fast!)
+    async function createApiContext(options, command) {
+        const opts = command?.optsWithGlobals ? command.optsWithGlobals() : options;
+        const outputFormat = getOutputFormat(command || { optsWithGlobals: () => ({ output: "json" }) });
+        const silent = outputFormat === "json" && !opts.verbose;
+        const log = (0, logger_js_1.createLogger)(opts.verbose, silent);
+        const baseDir = (0, utils_js_1.getBaseDir)();
+        const sessionPath = path_1.default.resolve(baseDir, ".auth", "storage-state.json");
+        // Check if session exists
+        if (!fs_1.default.existsSync(sessionPath)) {
+            return null;
+        }
+        // Try to load WS token
+        const wsToken = (0, token_js_1.loadWsToken)(sessionPath);
+        if (!wsToken) {
+            return null;
+        }
+        return {
+            log,
+            session: {
+                wsToken,
+                moodleBaseUrl: "https://ilearning.cycu.edu.tw",
+            },
+        };
+    }
+    // Helper function to create session context
+    async function createSessionContext(options, command) {
+        // Get global options if command is provided (for --verbose, --silent flags)
+        const opts = command?.optsWithGlobals ? command.optsWithGlobals() : options;
+        // Auto-enable silent mode for JSON output (unless --verbose is also set)
+        const outputFormat = getOutputFormat(command || { optsWithGlobals: () => ({ output: "json" }) });
+        const silent = outputFormat === "json" && !opts.verbose;
+        const log = (0, logger_js_1.createLogger)(opts.verbose, silent);
+        const baseDir = (0, utils_js_1.getBaseDir)();
+        const sessionPath = path_1.default.resolve(baseDir, ".auth", "storage-state.json");
+        if (!fs_1.default.existsSync(sessionPath)) {
+            log.error("未找到登入 session。請先執行 'openape auth login' 進行登入。");
+            return null;
+        }
+        const config = {
+            username: "",
+            password: "",
+            courseUrl: "",
+            moodleBaseUrl: "https://ilearning.cycu.edu.tw",
+            headless: !options.headed,
+            slowMo: 0,
+            authStatePath: sessionPath,
+            ollamaBaseUrl: "",
+        };
+        log.info("啟動瀏覽器...");
+        const { browser, context, page } = await (0, auth_js_1.launchAuthenticated)(config, log);
+        try {
+            const session = await (0, session_js_1.extractSessionInfo)(page, config, log);
+            return { log, page, session, browser, context };
+        }
+        catch (err) {
+            await context.close();
+            await browser.close();
+            throw err;
+        }
+    }
+    videosCmd
+        .command("list")
+        .description("List videos in a course")
+        .argument("<course-id>", "Course ID")
+        .option("--incomplete-only", "Show only incomplete videos")
+        .option("--output <format>", "Output format: json|csv|table|silent")
+        .action(async (courseId, options, command) => {
+        const output = getOutputFormat(command);
+        // Try pure API mode (no browser, fast!)
+        const apiContext = await createApiContext(options, command);
+        if (apiContext) {
+            try {
+                const videos = await (0, moodle_js_1.getSupervideosInCourseApi)(apiContext.session, parseInt(courseId, 10));
+                // Filter by incomplete only if requested (API returns all, no completion status)
+                // Note: API doesn't provide completion status, so --incomplete-only won't work in API mode
+                if (options.incompleteOnly) {
+                    apiContext.log.warn("--incomplete-only is not supported in API mode, showing all videos");
+                }
+                (0, index_js_1.formatAndOutput)(videos, output, apiContext.log);
+                return;
+            }
+            catch (e) {
+                // API failed, fall through to browser mode
+                const msg = e instanceof Error ? e.message : String(e);
+                console.error(`// API mode failed: ${msg}, trying browser mode...`);
+            }
+        }
+        // Fallback to browser mode
+        const context = await createSessionContext(options, command);
+        if (!context) {
+            process.exitCode = 1;
+            return;
+        }
+        const { log, page, session, browser, context: browserContext } = context;
+        try {
+            const videos = await (0, moodle_js_1.getSupervideosInCourse)(page, session, parseInt(courseId, 10), log, {
+                incompleteOnly: options.incompleteOnly,
+            });
+            (0, index_js_1.formatAndOutput)(videos, output, log);
+        }
+        finally {
+            await (0, auth_js_2.closeBrowserSafely)(browser, browserContext);
+        }
+    });
+    videosCmd
+        .command("complete")
+        .description("Complete videos in a course")
+        .argument("<course-id>", "Course ID")
+        .option("--dry-run", "Discover videos but don't complete them")
+        .option("--output <format>", "Output format: json|csv|table|silent")
+        .action(async (courseId, options, command) => {
+        const context = await createSessionContext(options, command);
+        if (!context) {
+            process.exitCode = 1;
+            return;
+        }
+        const { log, page, session, browser, context: browserContext } = context;
+        const output = getOutputFormat(command);
+        try {
+            const videos = await (0, moodle_js_1.getSupervideosInCourse)(page, session, parseInt(courseId, 10), log, {
+                incompleteOnly: true, // Only operate on incomplete videos
+            });
+            if (videos.length === 0) {
+                log.info("所有影片已完成（或無影片）。");
+                return;
+            }
+            const results = [];
+            for (const sv of videos) {
+                log.info(`處理中: ${sv.name}`);
+                try {
+                    const video = await (0, moodle_js_1.getVideoMetadata)(page, sv.url, log);
+                    if (options.dryRun) {
+                        log.info(`  [試執行] viewId=${video.viewId}, duration=${video.duration}s`);
+                        results.push({ name: sv.name, success: true });
+                        continue;
+                    }
+                    const success = await (0, moodle_js_1.completeVideo)(page, session, { ...video, cmid: sv.cmid }, log);
+                    if (success) {
+                        log.success(`  已完成！`);
+                        results.push({ name: sv.name, success: true });
+                    }
+                    else {
+                        log.error(`  失敗。`);
+                        results.push({ name: sv.name, success: false, error: "Failed to complete" });
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    log.error(`  錯誤: ${msg}`);
+                    results.push({ name: sv.name, success: false, error: msg });
+                }
+            }
+            const completed = results.filter(r => r.success).length;
+            const failed = results.filter(r => !r.success).length;
+            log.info(`\n執行結果: ${completed} 成功, ${failed} 失敗`);
+            if (output !== "silent") {
+                (0, index_js_1.formatAndOutput)(results, output, log);
+            }
+        }
+        finally {
+            await (0, auth_js_2.closeBrowserSafely)(browser, browserContext);
+        }
+    });
+    videosCmd
+        .command("complete-all")
+        .description("Complete all incomplete videos across all courses")
+        .option("--dry-run", "Discover videos but don't complete them")
+        .option("--output <format>", "Output format: json|csv|table|silent")
+        .action(async (options, command) => {
+        const context = await createSessionContext(options, command);
+        if (!context) {
+            process.exitCode = 1;
+            return;
+        }
+        const { log, page, session, browser, context: browserContext } = context;
+        const output = getOutputFormat(command);
+        try {
+            const courses = await (0, moodle_js_1.getEnrolledCourses)(page, session, log);
+            const allResults = [];
+            let totalVideos = 0;
+            let totalCompleted = 0;
+            let totalFailed = 0;
+            for (const course of courses) {
+                log.info(`\n======================================`);
+                log.info(`課程: ${course.fullname}`);
+                log.info(`======================================`);
+                const videos = await (0, moodle_js_1.getSupervideosInCourse)(page, session, course.id, log);
+                if (videos.length === 0) {
+                    log.info("  所有影片已完成（或無影片）。");
+                    continue;
+                }
+                totalVideos += videos.length;
+                for (const sv of videos) {
+                    log.info(`  處理中: ${sv.name}`);
+                    try {
+                        const video = await (0, moodle_js_1.getVideoMetadata)(page, sv.url, log);
+                        if (options.dryRun) {
+                            log.info(`    [試執行] viewId=${video.viewId}, duration=${video.duration}s`);
+                            allResults.push({ courseName: course.fullname, name: sv.name, success: true });
+                            continue;
+                        }
+                        const success = await (0, moodle_js_1.completeVideo)(page, session, { ...video, cmid: sv.cmid }, log);
+                        if (success) {
+                            log.success(`    已完成！`);
+                            allResults.push({ courseName: course.fullname, name: sv.name, success: true });
+                            totalCompleted++;
+                        }
+                        else {
+                            log.error(`    失敗。`);
+                            allResults.push({ courseName: course.fullname, name: sv.name, success: false, error: "Failed to complete" });
+                            totalFailed++;
+                        }
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        log.error(`    錯誤: ${msg}`);
+                        allResults.push({ courseName: course.fullname, name: sv.name, success: false, error: msg });
+                        totalFailed++;
+                    }
+                }
+            }
+            log.info("\n===== 執行結果 =====");
+            log.info(`掃描課程數: ${courses.length}`);
+            log.info(`掃描影片數: ${totalVideos}`);
+            log.info(`執行影片數: ${totalCompleted}`);
+            if (totalFailed > 0)
+                log.warn(`失敗影片數: ${totalFailed}`);
+            if (output !== "silent") {
+                (0, index_js_1.formatAndOutput)(allResults, output, log);
+            }
+        }
+        finally {
+            await (0, auth_js_2.closeBrowserSafely)(browser, browserContext);
+        }
+    });
+    // Helper function to sanitize filename
+    function sanitizeFilename(name) {
+        // Remove/replace invalid characters
+        return name
+            .replace(/[<>:"/\\|?*]/g, "_") // Replace invalid chars with underscore
+            .replace(/\s+/g, "_") // Replace spaces with underscores
+            .substring(0, 200); // Limit length
+    }
+    videosCmd
+        .command("download")
+        .description("Download videos from a course")
+        .argument("<course-id>", "Course ID")
+        .option("--output-dir <path>", "Output directory", "./downloads/videos")
+        .option("--incomplete-only", "Download only incomplete videos")
+        .action(async (courseId, options, command) => {
+        const context = await createSessionContext(options, command);
+        if (!context) {
+            process.exitCode = 1;
+            return;
+        }
+        const { log, page, session, browser, context: browserContext } = context;
+        try {
+            const videos = await (0, moodle_js_1.getSupervideosInCourse)(page, session, parseInt(courseId, 10), log, {
+                incompleteOnly: options.incompleteOnly,
+            });
+            log.info(`找到 ${videos.length} 個影片`);
+            // Create output directory
+            const baseDir = (0, utils_js_1.getBaseDir)();
+            const outputDir = path_1.default.resolve(baseDir, options.outputDir);
+            fs_1.default.mkdirSync(outputDir, { recursive: true });
+            const downloaded = [];
+            for (const video of videos) {
+                const filename = sanitizeFilename(video.name) + ".mp4";
+                const outputPath = path_1.default.join(outputDir, filename);
+                log.info(`處理中: ${video.name}`);
+                try {
+                    const metadata = await (0, moodle_js_1.getVideoMetadata)(page, video.url, log);
+                    const result = await (0, moodle_js_1.downloadVideo)(page, metadata, outputPath, log);
+                    if (result.success) {
+                        log.success(`  已下載: ${result.path}`);
+                        downloaded.push({ name: video.name, path: result.path, success: true, type: result.type });
+                    }
+                    else {
+                        log.warn(`  失敗: ${result.error}`);
+                        downloaded.push({ name: video.name, path: "", success: false, error: result.error, type: result.type });
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    log.error(`  錯誤: ${msg}`);
+                    downloaded.push({ name: video.name, path: "", success: false, error: msg });
+                }
+            }
+            const completed = downloaded.filter(d => d.success).length;
+            const failed = downloaded.filter(d => !d.success).length;
+            log.info(`\n執行結果: ${completed} 成功, ${failed} 失敗`);
+            const output = {
+                status: "success",
+                timestamp: new Date().toISOString(),
+                course_id: courseId,
+                output_dir: outputDir,
+                total_videos: videos.length,
+                downloaded: completed,
+                failed,
+                videos: downloaded,
+            };
+            console.log(JSON.stringify(output));
+        }
+        finally {
+            await (0, auth_js_2.closeBrowserSafely)(browser, browserContext);
+        }
+    });
+}
+exports.registerVideosCommand = registerVideosCommand;

package/script/src/index.d.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import "../_dnt.polyfills.js";
+import { createLogger } from "./lib/logger.js";
+import type { AppConfig, Logger, SessionInfo, OutputFormat } from "./lib/types.js";
+/**
+ * Create a session context for commands that need authentication.
+ */
+export declare function createSessionContext(options: {
+    config?: string;
+    session?: string;
+    verbose?: boolean;
+    silent?: boolean;
+    headed?: boolean;
+    interactive?: boolean;
+}): Promise<{
+    config: AppConfig;
+    log: Logger;
+    page: import("playwright-core").Page;
+    session: SessionInfo;
+} | null>;
+/**
+ * Helper to output formatted data.
+ * For JSON output (agent mode), exits immediately after output.
+ */
+export declare function formatAndOutput<T extends Record<string, unknown>>(data: T | T[], format: OutputFormat, log: Logger): void;
+export { createLogger, type AppConfig, type Logger, type SessionInfo, type OutputFormat };

package/script/src/index.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = exports.formatAndOutput = exports.createSessionContext = void 0;
+require("../_dnt.polyfills.js");
+const utils_js_1 = require("./lib/utils.js");
+const commander_1 = require("commander");
+const config_js_1 = require("./lib/config.js");
+const auth_js_1 = require("./lib/auth.js");
+const session_js_1 = require("./lib/session.js");
+const logger_js_1 = require("./lib/logger.js");
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return logger_js_1.createLogger; } });
+const deno_js_1 = __importDefault(require("../deno.js"));
+// Import command handlers
+const courses_js_1 = require("./commands/courses.js");
+const videos_js_1 = require("./commands/videos.js");
+const quizzes_js_1 = require("./commands/quizzes.js");
+const auth_js_2 = require("./commands/auth.js");
+const materials_js_1 = require("./commands/materials.js");
+const grades_js_1 = require("./commands/grades.js");
+const forums_js_1 = require("./commands/forums.js");
+const announcements_js_1 = require("./commands/announcements.js");
+const calendar_js_1 = require("./commands/calendar.js");
+const skills_js_1 = require("./commands/skills.js");
+const program = new commander_1.Command();
+program
+    .name("openape")
+    .description(deno_js_1.default.description)
+    .version(deno_js_1.default.version);
+// Global options
+program
+    .option("--config <path>", "Custom config file path")
+    .option("--session <path>", "Session file path", ".auth/storage-state.json")
+    .option("--output <format>", "Output format: json|csv|table|silent", "json")
+    .option("--verbose", "Enable debug logging")
+    .option("--silent", "Suppress all log output (JSON only)")
+    .option("--headed", "Run browser in visible mode");
+// Register subcommands
+(0, auth_js_2.registerAuthCommand)(program);
+(0, courses_js_1.registerCoursesCommand)(program);
+(0, videos_js_1.registerVideosCommand)(program);
+(0, quizzes_js_1.registerQuizzesCommand)(program);
+(0, materials_js_1.registerMaterialsCommand)(program);
+(0, grades_js_1.registerGradesCommand)(program);
+(0, forums_js_1.registerForumsCommand)(program);
+(0, announcements_js_1.registerAnnouncementsCommand)(program);
+(0, calendar_js_1.registerCalendarCommand)(program);
+(0, skills_js_1.registerSkillsCommand)(program);
+/**
+ * Load configuration and authenticate, returning the context for commands.
+ */
+async function createCommandContext(options) {
+    const log = (0, logger_js_1.createLogger)(options.verbose, options.silent);
+    const baseDir = (0, utils_js_1.getBaseDir)();
+    const config = (0, config_js_1.loadConfig)(baseDir);
+    // Apply CLI overrides
+    if (options.headed)
+        config.headless = false;
+    if (options.session)
+        config.authStatePath = options.session;
+    return { config, log };
+}
+/**
+ * Create a session context for commands that need authentication.
+ */
+async function createSessionContext(options) {
+    const context = await createCommandContext(options);
+    if (!context)
+        return null;
+    const { config, log } = context;
+    log.info("啟動瀏覽器...");
+    const { browser, context: browserContext, page, wsToken } = await (0, auth_js_1.launchAuthenticated)(config, log);
+    try {
+        const session = await (0, session_js_1.extractSessionInfo)(page, config, log, wsToken);
+        // Keep the browser context alive for the duration of the command
+        // Note: Caller is responsible for closing the browser
+        return { config, log, page, session };
+    }
+    catch (err) {
+        await browserContext.close();
+        await browser.close();
+        throw err;
+    }
+}
+exports.createSessionContext = createSessionContext;
+/**
+ * Helper to output formatted data.
+ * For JSON output (agent mode), exits immediately after output.
+ */
+function formatAndOutput(data, format, log) {
+    if (format === "json") {
+        console.log(JSON.stringify(data));
+        // Exit immediately for AI agent - no need to wait for browser cleanup
+        process.exit(0);
+    }
+    else if (format === "csv") {
+        const arr = Array.isArray(data) ? data : [data];
+        if (arr.length === 0)
+            return;
+        const fields = Object.keys(arr[0]);
+        console.log(formatAsCsv(arr, fields));
+    }
+    else if (format === "table") {
+        const arr = Array.isArray(data) ? data : [data];
+        if (arr.length === 0) {
+            console.log("No data");
+            return;
+        }
+        console.log(formatAsTable(arr));
+    }
+    // "silent" produces no output
+}
+exports.formatAndOutput = formatAndOutput;
+function formatAsCsv(data, fields) {
+    const headers = fields.join(",");
+    const rows = data.map((item) => {
+        return fields.map((field) => {
+            const value = item[field];
+            if (value === null || value === undefined)
+                return "";
+            if (typeof value === "string") {
+                if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+                    return `"${value.replace(/"/g, '""')}"`;
+                }
+                return value;
+            }
+            return String(value);
+        }).join(",");
+    });
+    return [headers, ...rows].join("\n");
+}
+function formatAsTable(data) {
+    const allFields = Array.from(new Set(data.flatMap((item) => Object.keys(item))));
+    const widths = {};
+    allFields.forEach((field) => {
+        widths[field] = Math.max(field.length, ...data.map((item) => String(item[field] ?? "").length)) + 2;
+    });
+    const header = allFields.map((f) => f.padEnd(widths[f])).join(" | ");
+    const separator = allFields.map((f) => "-".repeat(widths[f] - 1)).join("-+-");
+    const rows = data.map((item) => {
+        return allFields.map((f) => String(item[f] ?? "").padEnd(widths[f])).join(" | ");
+    });
+    return [header, separator, ...rows].join("\n");
+}
+// Run the program
+if ((require.main === module)) {
+    // If no subcommand provided, show help
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        program.help();
+    }
+    program.parse();
+}

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

@@ -0,0 +1,24 @@
+import { type Browser, type BrowserContext, type Page } from "playwright-core";
+import type { AppConfig, Logger } from "./types.js";
+/**
+ * Find a Chromium-based browser executable on Windows.
+ * Priority: Edge → Chrome → Brave
+ */
+export declare function findEdgePath(): string;
+/**
+ * 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.
+ */
+export declare function launchAuthenticated(config: AppConfig, log: Logger): Promise<{
+    browser: Browser;
+    context: BrowserContext;
+    page: Page;
+    wsToken?: string;
+}>;
+/**
+ * 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.
+ */
+export declare function closeBrowserSafely(browser: Browser, context?: BrowserContext, timeoutMs?: number, noWait?: boolean): Promise<void>;