@wilm-ai/wilma-cli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wilm.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# @wilm-ai/wilma-cli
+
+Command line interface for Wilma (Finnish school system), built for parents and AI agents.
+
+## Install
+```bash
+npm i -g @wilm-ai/wilma-cli
+# or
+pnpm add -g @wilm-ai/wilma-cli
+```
+
+## Run
+```bash
+wilma
+# or
+wilmai
+```
+
+## Non-interactive (agent-friendly)
+```bash
+wilma kids list --json
+wilma news list --all --json
+wilma messages list --folder inbox --all --json
+```
+
+## Config
+Local config is stored in `.wilmai/config.json` in the current working directory.
+Use `wilma config clear` to remove it.
+
+## Notes
+- Credentials are stored with lightweight obfuscation for convenience.
+- For multi-child accounts, you can pass `--student <id>` or `--all`.

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+export interface StoredProfile {
+    id: string;
+    tenantUrl: string;
+    username: string;
+    passwordObfuscated: string;
+    students?: {
+        studentNumber: string;
+        name: string;
+    }[];
+    lastStudentNumber?: string | null;
+    lastStudentName?: string | null;
+    lastUsedAt: string;
+}
+export interface CliConfig {
+    profiles: StoredProfile[];
+    lastProfileId?: string | null;
+}
+export declare function getConfigPath(): string;
+export declare function loadConfig(): Promise<CliConfig>;
+export declare function saveConfig(config: CliConfig): Promise<void>;
+export declare function clearConfig(): Promise<void>;
+export declare function obfuscateSecret(value: string): string;
+export declare function revealSecret(value: string): string | null;

package/dist/config.js

@@ -0,0 +1,61 @@
+import { mkdir, readFile, writeFile, rm } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+const SALT = "wilmai::";
+export function getConfigPath() {
+    const override = process.env.WILMAI_CONFIG_PATH;
+    if (override) {
+        return resolve(override);
+    }
+    return resolve(process.cwd(), ".wilmai", "config.json");
+}
+export async function loadConfig() {
+    const path = getConfigPath();
+    try {
+        const raw = await readFile(path, "utf-8");
+        const data = JSON.parse(raw);
+        if (!data.profiles) {
+            return { profiles: [] };
+        }
+        // Backward-compat: migrate single-student fields if present
+        data.profiles = data.profiles.map((p) => {
+            if (!p.students && p.studentNumber) {
+                p.students = [{ studentNumber: p.studentNumber, name: p.studentName ?? p.studentNumber }];
+            }
+            if (!p.lastStudentNumber && p.studentNumber) {
+                p.lastStudentNumber = p.studentNumber;
+                p.lastStudentName = p.studentName ?? p.studentNumber;
+            }
+            delete p.studentNumber;
+            delete p.studentName;
+            return p;
+        });
+        return data;
+    }
+    catch {
+        return { profiles: [] };
+    }
+}
+export async function saveConfig(config) {
+    const path = getConfigPath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, JSON.stringify(config, null, 2) + "\n", { encoding: "utf-8", mode: 0o600 });
+}
+export async function clearConfig() {
+    const path = getConfigPath();
+    await rm(path, { force: true });
+}
+export function obfuscateSecret(value) {
+    return Buffer.from(SALT + value, "utf-8").toString("base64");
+}
+export function revealSecret(value) {
+    try {
+        const decoded = Buffer.from(value, "base64").toString("utf-8");
+        if (!decoded.startsWith(SALT)) {
+            return null;
+        }
+        return decoded.slice(SALT.length);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,762 @@
+#!/usr/bin/env node
+import { select, input, password } from "@inquirer/prompts";
+import { WilmaClient, listTenants, } from "@wilm-ai/wilma-client";
+import { clearConfig, getConfigPath, loadConfig, obfuscateSecret, revealSecret, saveConfig, } from "./config.js";
+const ACTIONS = [
+    { value: "news", name: "List news" },
+    { value: "exams", name: "List exams" },
+    { value: "messages", name: "List messages" },
+    { value: "exit", name: "Exit" },
+];
+async function main() {
+    const args = process.argv.slice(2);
+    if (args[0] === "config" && args[1] === "clear") {
+        await clearConfig();
+        console.log(`Cleared config at ${getConfigPath()}`);
+        return;
+    }
+    const config = await loadConfig();
+    if (args.length) {
+        await handleCommand(args, config);
+        return;
+    }
+    await runInteractive(config);
+}
+async function chooseProfile(config) {
+    if (config.profiles.length) {
+        const choices = config.profiles.map((p) => ({
+            value: p.id,
+            name: `${p.username} @ ${p.tenantUrl} ${p.lastStudentName ? `(${p.lastStudentName})` : ""}`.trim(),
+        }));
+        choices.push({ value: "new", name: "Use a new login" });
+        const selected = await selectOrCancel({
+            message: "Choose a saved profile or create a new one",
+            choices,
+            default: config.lastProfileId ?? undefined,
+        });
+        if (selected === null)
+            return null;
+        if (selected !== "new") {
+            const stored = config.profiles.find((p) => p.id === selected);
+            if (!stored) {
+                throw new Error("Stored profile not found");
+            }
+            const secret = revealSecret(stored.passwordObfuscated);
+            if (!secret) {
+                throw new Error("Stored password could not be decoded");
+            }
+            const selectedStudent = await chooseStudentFromProfile(stored, {
+                baseUrl: stored.tenantUrl,
+                username: stored.username,
+                password: secret,
+            });
+            if (!selectedStudent) {
+                return null;
+            }
+            stored.lastUsedAt = new Date().toISOString();
+            stored.lastStudentNumber = selectedStudent?.studentNumber ?? null;
+            stored.lastStudentName = selectedStudent?.name ?? null;
+            config.lastProfileId = stored.id;
+            await saveConfig(config);
+            return {
+                baseUrl: stored.tenantUrl,
+                username: stored.username,
+                password: secret,
+                studentNumber: selectedStudent?.studentNumber ?? undefined,
+            };
+        }
+    }
+    const tenant = await selectTenant();
+    if (!tenant)
+        return null;
+    const username = await inputOrCancel({ message: "Wilma username" });
+    if (username === null)
+        return null;
+    const passwordValue = await passwordOrCancel({ message: "Wilma password" });
+    if (passwordValue === null)
+        return null;
+    const profileBase = {
+        baseUrl: tenant.url,
+        username,
+        password: passwordValue,
+    };
+    const students = await WilmaClient.listStudents(profileBase);
+    const student = await chooseStudent(students);
+    if (!student)
+        return null;
+    const finalProfile = {
+        ...profileBase,
+        studentNumber: student?.studentNumber ?? undefined,
+    };
+    const stored = {
+        id: `${tenant.url}|${username}`,
+        tenantUrl: tenant.url,
+        username,
+        passwordObfuscated: obfuscateSecret(passwordValue),
+        students: students.map((s) => ({ studentNumber: s.studentNumber, name: s.name })),
+        lastStudentNumber: student?.studentNumber ?? null,
+        lastStudentName: student?.name ?? null,
+        lastUsedAt: new Date().toISOString(),
+    };
+    config.profiles = config.profiles.filter((p) => p.id !== stored.id).concat(stored);
+    config.lastProfileId = stored.id;
+    await saveConfig(config);
+    return finalProfile;
+}
+async function runInteractive(config) {
+    while (true) {
+        const profile = await chooseProfile(config);
+        if (!profile)
+            return;
+        const client = await WilmaClient.login(profile);
+        let nextAction = await selectOrCancel({
+            message: "What do you want to view?",
+            choices: [
+                ...ACTIONS.filter((a) => a.value !== "exit"),
+                { value: "back", name: "Back to students" },
+                { value: "exit", name: "Exit" },
+            ],
+        });
+        if (nextAction === null) {
+            continue;
+        }
+        while (nextAction !== "exit" && nextAction !== "back") {
+            if (nextAction === "news") {
+                await selectNewsToRead(client);
+            }
+            if (nextAction === "exams") {
+                await outputExams(client, { limit: 20, json: false });
+            }
+            if (nextAction === "messages") {
+                const folder = await selectOrCancel({
+                    message: "Select folder",
+                    choices: [
+                        { value: "inbox", name: "Inbox" },
+                        { value: "archive", name: "Archive" },
+                        { value: "outbox", name: "Outbox" },
+                        { value: "drafts", name: "Drafts" },
+                        { value: "appointments", name: "Appointments" },
+                    ],
+                });
+                if (folder !== null) {
+                    await selectMessageToRead(client, folder);
+                }
+            }
+            nextAction = await selectOrCancel({
+                message: "What next?",
+                choices: [
+                    ...ACTIONS.filter((a) => a.value !== "exit"),
+                    { value: "back", name: "Back to students" },
+                    { value: "exit", name: "Exit" },
+                ],
+            });
+            if (nextAction === null) {
+                nextAction = "back";
+            }
+        }
+        if (nextAction === "exit") {
+            return;
+        }
+    }
+}
+async function selectTenant() {
+    const tenants = await listTenants();
+    let query = await inputOrCancel({
+        message: "Search tenant by city/name (blank to list all, or type URL)",
+        default: "",
+    });
+    if (query === null)
+        return null;
+    while (true) {
+        if (query.startsWith("http://") || query.startsWith("https://")) {
+            return {
+                url: query.trim().replace(/\/$/, ""),
+                name: query.trim(),
+                municipalities: [],
+            };
+        }
+        let filtered = tenants;
+        if (query.trim()) {
+            const search = query.trim().toLowerCase();
+            filtered = tenants.filter((t) => tenantMatches(search, t));
+        }
+        const choices = filtered.slice(0, 20).map((t) => ({
+            value: t.url,
+            name: `${t.name ?? t.url} (${t.url})`,
+        }));
+        choices.push({ value: "search", name: "Search again" });
+        choices.push({ value: "manual", name: "Enter URL manually" });
+        const selected = await selectOrCancel({
+            message: "Select tenant",
+            choices,
+        });
+        if (selected === null)
+            return null;
+        if (selected === "search") {
+            const nextQuery = await inputOrCancel({ message: "Search tenant by city/name (or type URL)" });
+            if (nextQuery === null)
+                return null;
+            query = nextQuery;
+            continue;
+        }
+        if (selected === "manual") {
+            const manual = await inputOrCancel({ message: "Tenant URL" });
+            if (manual === null)
+                return null;
+            return {
+                url: manual.trim().replace(/\/$/, ""),
+                name: manual.trim(),
+                municipalities: [],
+            };
+        }
+        const tenant = tenants.find((t) => t.url === selected);
+        if (!tenant) {
+            throw new Error("Tenant not found");
+        }
+        return tenant;
+    }
+}
+function tenantMatches(search, tenant) {
+    const needle = (search ?? "").toLowerCase();
+    if (fuzzyIncludes(tenant.name ?? "", needle)) {
+        return true;
+    }
+    if (fuzzyIncludes(tenant.url ?? "", needle)) {
+        return true;
+    }
+    const municipalities = Array.isArray(tenant.municipalities) ? tenant.municipalities : [];
+    for (const m of municipalities) {
+        if (!m)
+            continue;
+        if (fuzzyIncludes(m.nameFi ?? "", needle))
+            return true;
+        if (fuzzyIncludes(m.nameSv ?? "", needle))
+            return true;
+    }
+    return false;
+}
+function fuzzyIncludes(target, needle) {
+    const hay = (target ?? "").toLowerCase();
+    if (!needle)
+        return true;
+    if (hay.includes(needle))
+        return true;
+    let i = 0;
+    for (const ch of hay) {
+        if (ch === needle[i]) {
+            i += 1;
+            if (i >= needle.length)
+                return true;
+        }
+    }
+    return false;
+}
+async function chooseStudent(students) {
+    if (!students.length) {
+        const manual = await inputOrCancel({ message: "Student number (not found automatically)" });
+        if (manual === null)
+            return null;
+        return { studentNumber: manual.trim(), name: manual.trim(), href: `/!${manual.trim()}/` };
+    }
+    if (students.length === 1) {
+        return students[0];
+    }
+    const selected = await selectOrCancel({
+        message: "Select student",
+        choices: students.map((s) => ({
+            value: s.studentNumber,
+            name: `${s.name} (${s.studentNumber})`,
+        })),
+    });
+    if (selected === null)
+        return null;
+    return students.find((s) => s.studentNumber === selected) ?? null;
+}
+async function chooseStudentFromProfile(stored, baseProfile) {
+    let students = [];
+    const fresh = await WilmaClient.listStudents(baseProfile);
+    if (fresh.length) {
+        students = fresh;
+        stored.students = fresh.map((s) => ({ studentNumber: s.studentNumber, name: s.name }));
+    }
+    else if (stored.students && stored.students.length) {
+        students = stored.students.map((s) => ({
+            studentNumber: s.studentNumber,
+            name: s.name,
+            href: `/!${s.studentNumber}/`,
+        }));
+    }
+    const defaultStudent = stored.lastStudentNumber
+        ? students.find((s) => s.studentNumber === stored.lastStudentNumber)
+        : undefined;
+    if (!students.length) {
+        return null;
+    }
+    if (students.length === 1) {
+        return students[0];
+    }
+    const selected = await selectOrCancel({
+        message: "Select student",
+        default: defaultStudent?.studentNumber,
+        choices: students.map((s) => ({
+            value: s.studentNumber,
+            name: `${s.name} (${s.studentNumber})`,
+        })),
+    });
+    if (selected === null)
+        return null;
+    return students.find((s) => s.studentNumber === selected) ?? null;
+}
+async function handleCommand(args, config) {
+    const { command, subcommand, flags } = parseArgs(args);
+    if (command === "config" && subcommand === "clear") {
+        await clearConfig();
+        console.log(`Cleared config at ${getConfigPath()}`);
+        return;
+    }
+    const profile = await getProfileForCommandNonInteractive(config, flags);
+    if (!profile)
+        return;
+    const client = await WilmaClient.login(profile);
+    if (command === "kids") {
+        const students = await getStudentsForCommand(profile, config);
+        if (flags.json) {
+            console.log(JSON.stringify(students, null, 2));
+            return;
+        }
+        console.log("\nKids");
+        students.forEach((s) => {
+            console.log(`- ${s.studentNumber} ${s.name}`);
+        });
+        return;
+    }
+    if (command === "news") {
+        if (subcommand === "read" && flags.id) {
+            await outputNewsItem(client, Number(flags.id), flags.json);
+            return;
+        }
+        if (flags.allStudents) {
+            await outputAllNews(profile, config, flags.limit ?? 20, flags.json);
+            return;
+        }
+        const studentInfo = await resolveStudentForFlags(profile, config, flags.student);
+        if (!studentInfo && !profile.studentNumber) {
+            await printStudentSelectionHelp(profile, config);
+            return;
+        }
+        const perStudentClient = await WilmaClient.login({
+            ...profile,
+            studentNumber: studentInfo?.studentNumber ?? profile.studentNumber,
+        });
+        await outputNews(perStudentClient, {
+            limit: flags.limit ?? 20,
+            json: flags.json,
+            label: studentInfo?.name ?? undefined,
+        });
+        return;
+    }
+    if (command === "messages") {
+        if (subcommand === "read" && flags.id) {
+            await outputMessageItem(client, Number(flags.id), flags.json);
+            return;
+        }
+        if (flags.allStudents) {
+            await outputAllMessages(profile, config, {
+                folder: flags.folder ?? "inbox",
+                limit: flags.limit ?? 20,
+                json: flags.json,
+            });
+            return;
+        }
+        const studentInfo = await resolveStudentForFlags(profile, config, flags.student);
+        if (!studentInfo && !profile.studentNumber) {
+            await printStudentSelectionHelp(profile, config);
+            return;
+        }
+        const perStudentClient = await WilmaClient.login({
+            ...profile,
+            studentNumber: studentInfo?.studentNumber ?? profile.studentNumber,
+        });
+        await outputMessages(perStudentClient, {
+            folder: flags.folder ?? "inbox",
+            limit: flags.limit ?? 20,
+            json: flags.json,
+            label: studentInfo?.name ?? undefined,
+        });
+        return;
+    }
+    if (command === "exams") {
+        if (flags.allStudents) {
+            await outputAllExams(profile, config, flags.limit ?? 20, flags.json);
+            return;
+        }
+        const studentInfo = await resolveStudentForFlags(profile, config, flags.student);
+        if (!studentInfo && !profile.studentNumber) {
+            await printStudentSelectionHelp(profile, config);
+            return;
+        }
+        const perStudentClient = await WilmaClient.login({
+            ...profile,
+            studentNumber: studentInfo?.studentNumber ?? profile.studentNumber,
+        });
+        await outputExams(perStudentClient, {
+            limit: flags.limit ?? 20,
+            json: flags.json,
+            label: studentInfo?.name ?? undefined,
+        });
+        return;
+    }
+    console.log("Usage:");
+    console.log("  wilma kids list [--json]");
+    console.log("  wilma news list [--limit 20] [--student <id|name>] [--all-students] [--json]");
+    console.log("  wilma news read <id> [--json]");
+    console.log("  wilma messages list [--folder inbox] [--limit 20] [--student <id|name>] [--all-students] [--json]");
+    console.log("  wilma messages read <id> [--json]");
+    console.log("  wilma exams list [--limit 20] [--student <id|name>] [--all-students] [--json]");
+    console.log("  wilma config clear");
+}
+async function getProfileForCommandNonInteractive(config, flags) {
+    if (!config.lastProfileId) {
+        console.error("No saved profile found. Run the interactive CLI first.");
+        return null;
+    }
+    const stored = config.profiles.find((p) => p.id === config.lastProfileId);
+    if (!stored) {
+        console.error("Saved profile not found. Run the interactive CLI first.");
+        return null;
+    }
+    const secret = revealSecret(stored.passwordObfuscated);
+    if (!secret) {
+        console.error("Stored password could not be decoded. Re-login interactively.");
+        return null;
+    }
+    return {
+        baseUrl: stored.tenantUrl,
+        username: stored.username,
+        password: secret,
+        studentNumber: stored.lastStudentNumber ?? undefined,
+        debug: Boolean(flags.debug),
+    };
+}
+function parseArgs(args) {
+    const [command, subcommand, ...rest] = args;
+    const flags = {};
+    let i = 0;
+    while (i < rest.length) {
+        const arg = rest[i];
+        if (arg === "--json") {
+            flags.json = true;
+            i += 1;
+            continue;
+        }
+        if (arg === "--all-students" || arg === "--all") {
+            flags.allStudents = true;
+            i += 1;
+            continue;
+        }
+        if (arg === "--debug") {
+            flags.debug = true;
+            i += 1;
+            continue;
+        }
+        if (arg === "--limit") {
+            const value = Number(rest[i + 1]);
+            if (!Number.isNaN(value)) {
+                flags.limit = value;
+            }
+            i += 2;
+            continue;
+        }
+        if (arg === "--student") {
+            flags.student = rest[i + 1];
+            i += 2;
+            continue;
+        }
+        if (arg === "--folder") {
+            flags.folder = rest[i + 1];
+            i += 2;
+            continue;
+        }
+        if (!flags.id && !arg.startsWith("--")) {
+            flags.id = arg;
+            i += 1;
+            continue;
+        }
+        i += 1;
+    }
+    return { command, subcommand, flags };
+}
+async function outputNews(client, opts) {
+    const news = await client.news.list();
+    const slice = news.slice(0, opts.limit);
+    if (opts.json) {
+        console.log(JSON.stringify(slice, null, 2));
+        return;
+    }
+    console.log(`\nNews (${news.length})`);
+    slice.forEach((item) => {
+        const date = item.published ? item.published.toISOString().slice(0, 10) : "";
+        const prefix = opts.label ? `[${opts.label}] ` : "";
+        console.log(`- ${prefix}${date} ${compactText(item.title)} (id:${item.wilmaId})`.trim());
+    });
+}
+async function outputNewsItem(client, id, json) {
+    const item = await client.news.get(id);
+    if (json) {
+        console.log(JSON.stringify(item, null, 2));
+        return;
+    }
+    console.log(`\n${item.title}`);
+    if (item.subtitle)
+        console.log(item.subtitle);
+    if (item.published)
+        console.log(item.published.toISOString());
+    if (item.content)
+        console.log(`\n${formatContent(item.content)}`);
+}
+async function outputExams(client, opts) {
+    const exams = await client.exams.list();
+    const slice = exams.slice(0, opts.limit);
+    if (opts.json) {
+        console.log(JSON.stringify(slice, null, 2));
+        return;
+    }
+    console.log(`\nExams (${exams.length})`);
+    slice.forEach((exam) => {
+        const date = exam.examDate.toISOString().slice(0, 10);
+        const prefix = opts.label ? `[${opts.label}] ` : "";
+        console.log(`- ${prefix}${date} ${compactText(exam.subject)}`);
+    });
+}
+async function outputMessages(client, opts) {
+    const messages = await client.messages.list(opts.folder);
+    const slice = messages.slice(0, opts.limit);
+    if (opts.json) {
+        console.log(JSON.stringify(slice, null, 2));
+        return;
+    }
+    console.log(`\nMessages (${messages.length})`);
+    slice.forEach((msg) => {
+        const date = msg.sentAt.toISOString().slice(0, 10);
+        const prefix = opts.label ? `[${opts.label}] ` : "";
+        console.log(`- ${prefix}${date} ${compactText(msg.subject)} (id:${msg.wilmaId})`);
+    });
+}
+async function outputMessageItem(client, id, json) {
+    const msg = await client.messages.get(id);
+    if (json) {
+        console.log(JSON.stringify(msg, null, 2));
+        return;
+    }
+    console.log(`\n${msg.subject}`);
+    if (msg.senderName)
+        console.log(`From: ${msg.senderName}`);
+    console.log(`Sent: ${msg.sentAt.toISOString()}`);
+    if (msg.content)
+        console.log(`\n${formatContent(msg.content)}`);
+}
+async function selectNewsToRead(client) {
+    const news = await client.news.list();
+    if (!news.length)
+        return;
+    const choices = news.slice(0, 30).map((item) => {
+        const date = item.published ? item.published.toISOString().slice(0, 10) : "";
+        return {
+            value: String(item.wilmaId),
+            name: `${date} ${compactText(item.title)}`.trim(),
+        };
+    });
+    choices.unshift({ value: "back", name: "Back" });
+    const selected = await selectOrCancel({
+        message: "Read which news item?",
+        choices,
+    });
+    if (!selected || selected === "back")
+        return;
+    await outputNewsItem(client, Number(selected), false);
+}
+async function selectMessageToRead(client, folder) {
+    const messages = await client.messages.list(folder);
+    if (!messages.length)
+        return;
+    const choices = messages.slice(0, 30).map((msg) => {
+        const date = msg.sentAt.toISOString().slice(0, 10);
+        return {
+            value: String(msg.wilmaId),
+            name: `${date} ${compactText(msg.subject)}`.trim(),
+        };
+    });
+    choices.unshift({ value: "back", name: "Back" });
+    const selected = await selectOrCancel({
+        message: "Read which message?",
+        choices,
+    });
+    if (!selected || selected === "back")
+        return;
+    await outputMessageItem(client, Number(selected), false);
+}
+async function selectOrCancel(opts) {
+    try {
+        return (await select(opts));
+    }
+    catch (err) {
+        if (isPromptCancel(err)) {
+            return null;
+        }
+        throw err;
+    }
+}
+async function inputOrCancel(opts) {
+    try {
+        return await input(opts);
+    }
+    catch (err) {
+        if (isPromptCancel(err)) {
+            return null;
+        }
+        throw err;
+    }
+}
+async function passwordOrCancel(opts) {
+    try {
+        return await password(opts);
+    }
+    catch (err) {
+        if (isPromptCancel(err)) {
+            return null;
+        }
+        throw err;
+    }
+}
+function isPromptCancel(err) {
+    if (!err)
+        return false;
+    const message = err instanceof Error ? err.message : String(err);
+    const name = err instanceof Error ? err.name : "";
+    return (name === "AbortError" ||
+        name === "ExitPromptError" ||
+        message.includes("User force closed the prompt") ||
+        message.toLowerCase().includes("cancel") ||
+        message.toLowerCase().includes("aborted"));
+}
+function compactText(value) {
+    return (value ?? "").replace(/\s+/g, " ").trim();
+}
+function formatContent(value) {
+    const lines = value
+        .replace(/\r/g, "")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line, index, arr) => {
+        if (line !== "")
+            return true;
+        // Keep a single blank line between blocks
+        return arr[index - 1] !== "";
+    });
+    return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function getStudentsForCommand(profile, config) {
+    const stored = config.profiles.find((p) => p.id === config.lastProfileId);
+    const fresh = await WilmaClient.listStudents(profile);
+    if (stored) {
+        stored.students = fresh.map((s) => ({ studentNumber: s.studentNumber, name: s.name }));
+        await saveConfig(config);
+    }
+    return fresh;
+}
+async function resolveStudentForFlags(profile, config, student) {
+    if (student) {
+        const students = await getStudentsForCommand(profile, config);
+        const exact = students.find((s) => s.studentNumber === student);
+        if (exact)
+            return exact;
+        const match = students.find((s) => fuzzyIncludes(s.name, student));
+        if (match)
+            return match;
+        return { studentNumber: student, name: student, href: `/!${student}/` };
+    }
+    const stored = config.profiles.find((p) => p.id === config.lastProfileId);
+    if (stored?.lastStudentNumber) {
+        return {
+            studentNumber: stored.lastStudentNumber,
+            name: stored.lastStudentName ?? stored.lastStudentNumber,
+            href: `/!${stored.lastStudentNumber}/`,
+        };
+    }
+    const students = await getStudentsForCommand(profile, config);
+    return students[0] ?? null;
+}
+async function outputAllNews(profile, config, limit, json) {
+    const students = await getStudentsForCommand(profile, config);
+    const results = [];
+    for (const student of students) {
+        const client = await WilmaClient.login({ ...profile, studentNumber: student.studentNumber });
+        const news = await client.news.list();
+        results.push({ student, items: news.slice(0, limit) });
+    }
+    if (json) {
+        console.log(JSON.stringify({ students: results }, null, 2));
+        return;
+    }
+    results.forEach((entry) => {
+        console.log(`\n[${entry.student.name}]`);
+        entry.items.forEach((item) => {
+            const date = item.published ? item.published.toISOString().slice(0, 10) : "";
+            console.log(`- ${date} ${item.title} (id:${item.wilmaId})`.trim());
+        });
+    });
+}
+async function outputAllMessages(profile, config, opts) {
+    const students = await getStudentsForCommand(profile, config);
+    const results = [];
+    for (const student of students) {
+        const client = await WilmaClient.login({ ...profile, studentNumber: student.studentNumber });
+        const messages = await client.messages.list(opts.folder);
+        results.push({ student, items: messages.slice(0, opts.limit) });
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ students: results }, null, 2));
+        return;
+    }
+    results.forEach((entry) => {
+        console.log(`\n[${entry.student.name}]`);
+        entry.items.forEach((msg) => {
+            const date = msg.sentAt.toISOString().slice(0, 10);
+            console.log(`- ${date} ${msg.subject} (id:${msg.wilmaId})`);
+        });
+    });
+}
+async function outputAllExams(profile, config, limit, json) {
+    const students = await getStudentsForCommand(profile, config);
+    const results = [];
+    for (const student of students) {
+        const client = await WilmaClient.login({ ...profile, studentNumber: student.studentNumber });
+        const exams = await client.exams.list();
+        results.push({ student, items: exams.slice(0, limit) });
+    }
+    if (json) {
+        console.log(JSON.stringify({ students: results }, null, 2));
+        return;
+    }
+    results.forEach((entry) => {
+        console.log(`\n[${entry.student.name}]`);
+        entry.items.forEach((exam) => {
+            const date = exam.examDate.toISOString().slice(0, 10);
+            console.log(`- ${date} ${exam.subject}`);
+        });
+    });
+}
+async function printStudentSelectionHelp(profile, config) {
+    const students = await getStudentsForCommand(profile, config);
+    console.error("Multiple students found. Use --student <id|name> or --all-students.");
+    students.forEach((s) => {
+        console.error(`- ${s.studentNumber} ${s.name}`);
+    });
+}
+main().catch((err) => {
+    if (isPromptCancel(err)) {
+        process.exit(0);
+    }
+    console.error("CLI error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@wilm-ai/wilma-cli",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "wilmai": "dist/index.js",
+    "wilma": "dist/index.js"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^5.3.8",
+    "@wilm-ai/wilma-client": "^0.0.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "echo 'add lint'",
+    "test": "echo 'add tests'",
+    "start": "node dist/index.js",
+    "test:live": "tsc -p tsconfig.json && node test/live.spec.mjs"
+  }
+}