@wilm-ai/wilma-client 0.0.1

package/dist/session.js

@@ -0,0 +1,205 @@
+import { CookieJar } from "tough-cookie";
+import { fetch } from "undici";
+export class AuthenticationError extends Error {
+}
+export class APIError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0 Safari/537.36";
+const LOGIN_FAIL_RE = /loginFailed/i;
+export class WilmaSession {
+    baseUrl;
+    cookieJar;
+    loggedIn = false;
+    username;
+    password;
+    studentNumber;
+    debug = false;
+    constructor(baseUrl, opts) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.cookieJar = new CookieJar();
+        this.studentNumber = opts?.studentNumber ?? null;
+        this.debug = Boolean(opts?.debug);
+    }
+    get urlPrefix() {
+        return this.studentNumber ? `!${this.studentNumber}` : null;
+    }
+    getPrefixedPath(path) {
+        if (this.urlPrefix && !path.startsWith("/!")) {
+            if (path.startsWith("/")) {
+                return `/${this.urlPrefix}${path}`;
+            }
+            return `/${this.urlPrefix}/${path}`;
+        }
+        return path;
+    }
+    async login(username, password) {
+        if (this.loggedIn) {
+            return;
+        }
+        const loginFields = await this.getLoginFormFields();
+        let sessionId = loginFields.SESSIONID;
+        if (!sessionId) {
+            sessionId = await this.getLoginToken();
+        }
+        const form = new URLSearchParams({
+            ...loginFields,
+            Login: username,
+            Password: password,
+            SESSIONID: sessionId,
+        });
+        const resp = await this.rawRequest("/login", {
+            method: "POST",
+            body: form.toString(),
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            redirect: "manual",
+        });
+        const hasSessionCookie = this.cookieJar
+            .getCookiesSync(this.baseUrl)
+            .some((c) => c.key === "Wilma2SID");
+        const text = await resp.text();
+        if (hasSessionCookie || isLoginOk(text)) {
+            this.loggedIn = true;
+            this.username = username;
+            this.password = password;
+            return;
+        }
+        throw new AuthenticationError("Wilma login failed");
+    }
+    async getLoginFormFields() {
+        const resp = await this.rawRequest("/login", { method: "GET" });
+        if (resp.status >= 400) {
+            return {};
+        }
+        const html = await resp.text();
+        return parseLoginFormFields(html);
+    }
+    async request(path, init) {
+        if (!this.loggedIn) {
+            throw new AuthenticationError("WilmaSession not logged in – call login() first");
+        }
+        const prefixedPath = this.getPrefixedPath(path);
+        let resp = await this.rawRequest(prefixedPath, init);
+        if (resp.status === 401 && this.username && this.password) {
+            this.loggedIn = false;
+            await this.login(this.username, this.password);
+            resp = await this.rawRequest(prefixedPath, init);
+        }
+        if (resp.status >= 400) {
+            throw new APIError(`Wilma HTTP ${resp.status} at ${prefixedPath}`, resp.status);
+        }
+        return resp;
+    }
+    async get(path, init) {
+        return this.request(path, { ...init, method: "GET" });
+    }
+    async post(path, init) {
+        return this.request(path, { ...init, method: "POST" });
+    }
+    async getLoginToken() {
+        const resp = await this.rawRequest("/token", { method: "GET" });
+        if (resp.status !== 200) {
+            throw new AuthenticationError("/token fetch failed");
+        }
+        const text = await resp.text();
+        try {
+            const data = JSON.parse(text);
+            if (data.Wilma2LoginID) {
+                return data.Wilma2LoginID;
+            }
+        }
+        catch {
+            // fall through to regex
+        }
+        const match = /"Wilma2LoginID"\s*:\s*"([^"\s]+)"/.exec(text);
+        if (!match) {
+            throw new AuthenticationError("Wilma2LoginID not found in /token response");
+        }
+        return match[1];
+    }
+    async rawRequest(path, init) {
+        const url = new URL(path, this.baseUrl).toString();
+        const cookieHeader = this.cookieJar.getCookieStringSync(url);
+        const headers = new Headers();
+        if (init?.headers) {
+            const incoming = init.headers;
+            if (incoming instanceof Headers) {
+                incoming.forEach((value, key) => headers.set(key, value));
+            }
+            else if (Array.isArray(incoming)) {
+                for (const entry of incoming) {
+                    if (entry.length >= 2) {
+                        headers.set(entry[0], entry[1]);
+                    }
+                }
+            }
+            else {
+                for (const [key, value] of Object.entries(incoming)) {
+                    if (value !== undefined) {
+                        headers.set(key, String(value));
+                    }
+                }
+            }
+        }
+        headers.set("User-Agent", USER_AGENT);
+        headers.set("Referer", `${this.baseUrl}/`);
+        if (cookieHeader) {
+            headers.set("Cookie", cookieHeader);
+        }
+        if (this.debug) {
+            const method = init?.method ?? "GET";
+            // Avoid logging sensitive headers or body
+            console.log(`[wilmai] ${method} ${url}`);
+        }
+        const resp = await fetch(url, {
+            ...init,
+            headers,
+        });
+        const headersAny = resp.headers;
+        const setCookies = headersAny.getSetCookie?.() ?? [];
+        if (setCookies.length) {
+            for (const cookie of setCookies) {
+                this.cookieJar.setCookieSync(cookie, url);
+            }
+        }
+        else {
+            const single = resp.headers.get("set-cookie");
+            if (single) {
+                this.cookieJar.setCookieSync(single, url);
+            }
+        }
+        return resp;
+    }
+}
+function isLoginOk(text) {
+    return !LOGIN_FAIL_RE.test(text);
+}
+function parseLoginFormFields(html) {
+    const fields = {};
+    const inputRegex = /<input[^>]+>/gi;
+    const nameRegex = /name=['"]([^'"]+)['"]/i;
+    const valueRegex = /value=['"]([^'"]*)['"]/i;
+    const typeRegex = /type=['"]([^'"]+)['"]/i;
+    const matches = html.match(inputRegex) ?? [];
+    for (const tag of matches) {
+        const name = nameRegex.exec(tag)?.[1];
+        if (!name)
+            continue;
+        const type = typeRegex.exec(tag)?.[1]?.toLowerCase() ?? "text";
+        if (name === "Login" || name === "Password") {
+            continue;
+        }
+        if (type === "hidden" || type === "submit") {
+            const value = valueRegex.exec(tag)?.[1] ?? "";
+            fields[name] = value;
+        }
+    }
+    return fields;
+}

package/dist/tenants.d.ts

@@ -0,0 +1,5 @@
+import type { TenantDiscoveryResponse, TenantInfo } from "./types.js";
+export declare function loadTenantDiscovery(): Promise<TenantDiscoveryResponse>;
+export declare function listTenants(): Promise<TenantInfo[]>;
+export declare function searchTenantsByMunicipality(municipality: string, limit?: number): Promise<TenantInfo[]>;
+export declare function findTenantByUrl(url: string): Promise<TenantInfo | null>;

package/dist/tenants.js

@@ -0,0 +1,35 @@
+import { readFile } from "node:fs/promises";
+const TENANT_LIST_URL = new URL("../tenant_list.json", import.meta.url);
+export async function loadTenantDiscovery() {
+    const raw = await readFile(TENANT_LIST_URL, "utf-8");
+    const data = JSON.parse(raw);
+    if (!data || !Array.isArray(data.wilmat)) {
+        throw new Error("Invalid tenant list format");
+    }
+    return data;
+}
+export async function listTenants() {
+    const data = await loadTenantDiscovery();
+    return data.wilmat;
+}
+export async function searchTenantsByMunicipality(municipality, limit = 50) {
+    const data = await loadTenantDiscovery();
+    const needle = (municipality ?? "").toLowerCase();
+    const results = data.wilmat.filter((tenant) => {
+        const municipalities = Array.isArray(tenant.municipalities) ? tenant.municipalities : [];
+        return municipalities.some((m) => {
+            if (!m) {
+                return false;
+            }
+            const nameFi = (m.nameFi ?? "").toLowerCase();
+            const nameSv = (m.nameSv ?? "").toLowerCase();
+            return nameFi.includes(needle) || nameSv.includes(needle);
+        });
+    });
+    return results.slice(0, limit);
+}
+export async function findTenantByUrl(url) {
+    const data = await loadTenantDiscovery();
+    const target = url.replace(/\/$/, "");
+    return data.wilmat.find((t) => t.url.replace(/\/$/, "") === target) ?? null;
+}

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+export type MessageFolder = "inbox" | "archive" | "outbox" | "drafts" | "appointments";
+export interface Message {
+    wilmaId: number;
+    subject: string;
+    sentAt: Date;
+    folder: MessageFolder | string;
+    senderId?: number | null;
+    senderType?: number | null;
+    senderName?: string | null;
+    sendersJson?: Record<string, unknown> | null;
+    status?: number | null;
+    content?: string | null;
+    fetchedAt: Date;
+}
+export interface NewsItem {
+    wilmaId: number;
+    title: string;
+    subtitle?: string | null;
+    author?: string | null;
+    published?: Date | null;
+    content?: string | null;
+    fetchedAt: Date;
+}
+export interface Exam {
+    wilmaId: number;
+    examDate: Date;
+    subject: string;
+    description?: string | null;
+    teacher?: string | null;
+    notes?: string | null;
+    fetchedAt: Date;
+}
+export interface StudentInfo {
+    studentNumber: string;
+    name: string;
+    href: string;
+}
+export interface Municipality {
+    nameFi: string;
+    nameSv: string;
+}
+export interface TenantInfo {
+    url: string;
+    name: string;
+    municipalities: Municipality[];
+    formerUrl?: string | null;
+}
+export interface TenantDiscoveryResponse {
+    wilmat: TenantInfo[];
+}
+export interface WilmaProfile {
+    baseUrl: string;
+    username: string;
+    password: string;
+    studentNumber?: string | null;
+    debug?: boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@wilm-ai/wilma-client",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "tenant_list.json"
+  ],
+  "dependencies": {
+    "cheerio": "^1.0.0-rc.12",
+    "tough-cookie": "^4.1.4",
+    "undici": "^6.19.8"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "@types/tough-cookie": "^4.0.5"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "echo 'add lint'",
+    "test": "echo 'add tests'",
+    "test:smoke": "tsc -p tsconfig.json && node test/smoke.mjs",
+    "test:live": "tsc -p tsconfig.json && node test/live.spec.mjs"
+  }
+}