@wilm-ai/wilma-cli 2.1.1 → 2.2.0

package/README.md

@@ -18,6 +18,12 @@ Opens a one-time login page in your browser: pick your school's Wilma and log in
 
 Without a browser: `wilma login --tenant <url|city> --username <name>` with the password in `WILMA_PASSWORD` or piped via `--password-stdin`. Or set `WILMA_TENANT`, `WILMA_USERNAME`, `WILMA_PASSWORD` (and `WILMA_TOTP_SECRET`) and skip the saved login.
 
+## Log out
+```bash
+wilma logout                  # every saved login; `wilma logout 2` for one (numbers from `wilma accounts`)
+```
+Wilma allows one session per account: when WilmAI logs in, Wilma logs you out in your browser, and the other way round. `wilma logout` ends WilmAI's session, as Wilma's own Log out does, so you can use Wilma in the browser. The logins stay saved, and the next command logs in again. `wilma config clear` deletes the logins as well.
+
 ## Use it
 ```bash
 wilma summary                 # the daily briefing for every child — start here
@@ -53,7 +59,7 @@ Running `wilma` without arguments in a terminal opens an interactive menu.
 ```bash
 wilma mcp
 ```
-Starts a stdio MCP server with read-only Wilma tools (`wilma_summary`, `wilma_schedule`, `wilma_read_news`, …) that return the same data as the commands. Add it to any MCP client as `npx -y @wilm-ai/wilma-cli@2 mcp`. Setup guides for Claude, ChatGPT, Grok Bot and OpenClaw: https://wilm.ai
+Starts a stdio MCP server with read-only Wilma tools (`wilma_summary`, `wilma_schedule`, `wilma_read_news`, …) that return the same data as the commands, plus `wilma_logout`, which ends WilmAI's Wilma session like `wilma logout`. Add it to any MCP client as `npx -y @wilm-ai/wilma-cli@2 mcp`. Setup guides for Claude, ChatGPT, Grok Bot and OpenClaw: https://wilm.ai
 
 ## Bulletin attachments
 `wilma news <id>` lists every link in a bulletin (`resources`). Any resource can be downloaded with `wilma news <id> download <resource> [--output <directory>]` (the resource id also accepts a bare number, e.g. `1` for `resource-1`). Wilma-hosted files download through the session; external links are fetched without your Wilma login, and only from public websites. The result's `status` says what happened: `downloaded` (use the returned `path`) or `not_a_file` when the link answered with a web page (for example a sharing link that needs signing in — open it in a browser instead). `--output` defaults to the current directory; existing files are never overwritten.
@@ -62,7 +68,7 @@ Starts a stdio MCP server with read-only Wilma tools (`wilma_summary`, `wilma_sc
 Children at schools on different Wilmas need one login per Wilma. Run `wilma login` again (or press "Add another Wilma" on the login page); commands then cover every child, and each child carries the `wilma` it belongs to.
 ```bash
 wilma accounts                     # saved logins, numbered
-wilma accounts remove <number>     # or the Wilma name or username
+wilma accounts remove <number>     # or the Wilma name or username; also ends that login's Wilma session
 ```
 
 ## Find your Wilma
@@ -86,7 +92,7 @@ If your Wilma account has MFA/TOTP enabled:
 **Without a saved login:** set `WILMA_TOTP_SECRET` along with the other `WILMA_*` variables. `--totp-secret <key>` also works, but a key on the command line ends up in shell history and is visible to other programs on the computer.
 
 ## Config
-Logins are saved in `~/.config/wilmai/config.json` (or `$XDG_CONFIG_HOME/wilmai/config.json`; override with `WILMAI_CONFIG_PATH`) and the current Wilma sessions in `wilmai-sessions.json` next to it, both readable only by you. `wilma config clear` deletes both.
+Logins are saved in `~/.config/wilmai/config.json` (or `$XDG_CONFIG_HOME/wilmai/config.json`; override with `WILMAI_CONFIG_PATH`) and the current Wilma sessions in `wilmai-sessions.json` next to it, both readable only by you. `wilma logout` ends the sessions and deletes them, keeping the logins; `wilma config clear` deletes both.
 
 ## Troubleshooting: TLS errors on a managed laptop
 

package/dist/access.d.ts

@@ -10,3 +10,17 @@ export declare function createAccess(accounts: ActiveAccount[], opts?: {
     debug?: boolean;
     totpSecret?: string;
 }): WilmaAccess;
+/**
+ * End WilmAI's Wilma session for each login (see logoutSession), for `wilma
+ * logout` and the wilma_logout tool. The logins stay saved. Tries every login
+ * (different Wilmas don't affect each other), then throws the first failure.
+ */
+export declare function logoutAccounts(accounts: ActiveAccount[]): Promise<{
+    status: "ok";
+    logins: {
+        wilma: string;
+        username: string;
+        session: "none" | "ended";
+    }[];
+    hint: string;
+}>;

package/dist/access.js

@@ -1,4 +1,4 @@
-import { WilmaAccess } from "./agent-data.js";
+import { WilmaAccess, logoutSession } from "./agent-data.js";
 import { loadConfig, saveConfig } from "./config.js";
 import { mfaCallbackFor } from "./credentials.js";
 /**
@@ -31,3 +31,26 @@ export function createAccess(accounts, opts = {}) {
         },
     })));
 }
+/**
+ * End WilmAI's Wilma session for each login (see logoutSession), for `wilma
+ * logout` and the wilma_logout tool. The logins stay saved. Tries every login
+ * (different Wilmas don't affect each other), then throws the first failure.
+ */
+export async function logoutAccounts(accounts) {
+    const results = await Promise.allSettled(accounts.map((account) => logoutSession(account.profile)));
+    const failed = results.find((result) => result.status === "rejected");
+    if (failed)
+        throw failed.reason;
+    const logins = accounts.map((account, index) => ({
+        wilma: account.stored?.tenantName ?? account.profile.baseUrl,
+        username: account.profile.username,
+        session: results[index].value ? "ended" : "none",
+    }));
+    return {
+        status: "ok",
+        logins,
+        hint: logins.length
+            ? "The logins stay saved. The next time WilmAI reads Wilma it logs in again, and that ends the user's Wilma session in the browser."
+            : "No saved Wilma login, so there was nothing to log out.",
+    };
+}

package/dist/agent-data.d.ts

@@ -73,8 +73,23 @@ export declare function useSessionStore(store: SessionStore | undefined): void;
  * verification, no second code).
  */
 export declare function adoptSession(profile: WilmaProfile, client: WilmaClient): void;
-/** Save any sessions still being written (call before a short-lived process exits). */
+/**
+ * Finish saving sessions (call before a short-lived process exits). Only
+ * logins made here are saved, never an older session over a newer one
+ * another process saved meanwhile.
+ */
 export declare function flushSessions(): Promise<void>;
+/**
+ * End WilmAI's Wilma session for one login (Wilma's own "Log out") and forget
+ * it, in this process and in the session store, so nothing continues it. The
+ * login itself stays saved; the next command or tool call logs in again.
+ * Never logs in. Returns true when a live session was ended, false when there
+ * was none. If Wilma can't be reached, throws and keeps the saved session, so
+ * logging out can be tried again.
+ */
+export declare function logoutSession(profile: WilmaProfile): Promise<boolean>;
+/** Forget one login's session without ending it in Wilma (when the login itself is removed). */
+export declare function forgetSession(profile: WilmaProfile): Promise<void>;
 /**
  * Read-only Wilma access for agent tools (MCP). Covers every Wilma login the
  * family has saved; every method defaults to all children, and a student

package/dist/agent-data.js

@@ -237,14 +237,29 @@ let sessionStore;
 export function useSessionStore(store) {
     sessionStore = store;
 }
-function rememberSession(key, client) {
+/**
+ * Save the session for the other processes, and share theirs: when Wilma ends
+ * this one, the client first continues the newest session another process
+ * saved (a CLI command, an assistant's connector, the desktop app), and logs
+ * in only when that one has ended too. Each login ends the others, so this
+ * keeps WilmAI's programs from logging each other out.
+ */
+function rememberSession(key, client, opts) {
     const store = sessionStore;
     if (!store)
         return;
-    const save = () => store.save(key, client.exportSession()).catch(() => { });
-    client.onLogin(() => void save());
-    void save();
+    const save = (state) => {
+        const saving = store.save(key, state).catch(() => { });
+        pendingSaves.add(saving);
+        void saving.finally(() => pendingSaves.delete(saving));
+        return saving;
+    };
+    client.useSharedSession({ load: () => store.load(key), save });
+    // A resumed session is already saved (and another process may have saved a newer one since).
+    if (opts.fresh)
+        void save(client.exportSession());
 }
+const pendingSaves = new Set();
 /** Identifies one Wilma account and password (a changed password starts fresh). */
 function poolKey(profile) {
     const { baseUrl, username, password } = profile;
@@ -261,17 +276,50 @@ function poolKey(profile) {
 export function adoptSession(profile, client) {
     const key = poolKey(profile);
     pool.set(key, { client: Promise.resolve(client), lastUsed: Date.now() });
-    rememberSession(key, client);
+    rememberSession(key, client, { fresh: true });
 }
-/** Save any sessions still being written (call before a short-lived process exits). */
+/**
+ * Finish saving sessions (call before a short-lived process exits). Only
+ * logins made here are saved, never an older session over a newer one
+ * another process saved meanwhile.
+ */
 export async function flushSessions() {
-    if (!sessionStore)
-        return;
-    for (const [key, entry] of pool) {
-        const client = await entry.client.catch(() => null);
-        if (client)
-            await sessionStore.save(key, client.exportSession()).catch(() => { });
-    }
+    for (const entry of pool.values())
+        await entry.client.catch(() => null);
+    await Promise.all([...pendingSaves]);
+}
+/**
+ * End WilmAI's Wilma session for one login (Wilma's own "Log out") and forget
+ * it, in this process and in the session store, so nothing continues it. The
+ * login itself stays saved; the next command or tool call logs in again.
+ * Never logs in. Returns true when a live session was ended, false when there
+ * was none. If Wilma can't be reached, throws and keeps the saved session, so
+ * logging out can be tried again.
+ */
+export async function logoutSession(profile) {
+    const key = poolKey(profile);
+    const entry = pool.get(key);
+    // The session in use here (a login in progress finishes first) and the saved
+    // one, which another process may have replaced since. At most one is live.
+    const pooled = entry ? await entry.client.catch(() => null) : null;
+    const pooledState = pooled?.exportSession();
+    const saved = sessionStore ? await sessionStore.load(key).catch(() => null) : null;
+    let ended = pooled ? await pooled.logout() : false;
+    if (pool.get(key) === entry)
+        pool.delete(key);
+    if (saved && saved !== pooledState) {
+        const resumed = WilmaClient.resume({ ...profile, studentNumber: null }, saved);
+        if (resumed && (await resumed.logout()))
+            ended = true;
+    }
+    await sessionStore?.remove(key);
+    return ended;
+}
+/** Forget one login's session without ending it in Wilma (when the login itself is removed). */
+export async function forgetSession(profile) {
+    const key = poolKey(profile);
+    pool.delete(key);
+    await sessionStore?.remove(key);
 }
 function pooledSession(account) {
     const now = Date.now();
@@ -287,9 +335,9 @@ function pooledSession(account) {
             // A saved session first; it logs in again by itself if Wilma has ended it.
             const saved = sessionStore ? await sessionStore.load(key).catch(() => null) : null;
             const resumed = saved ? WilmaClient.resume(profile, saved, account.mfa) : null;
-            const fresh = resumed ?? (await WilmaClient.login(profile, account.mfa));
-            rememberSession(key, fresh);
-            return fresh;
+            const client = resumed ?? (await WilmaClient.login(profile, account.mfa));
+            rememberSession(key, client, { fresh: !resumed });
+            return client;
         })();
         const created = { client, lastUsed: now };
         entry = created;

package/dist/cli-args.js

@@ -13,7 +13,7 @@ const DATA_COMMANDS = [
     "printouts",
     "students",
 ];
-const OTHER_COMMANDS = ["accounts", "find-school", "login", "mcp", "update", "config", "help"];
+const OTHER_COMMANDS = ["accounts", "find-school", "login", "logout", "mcp", "update", "config", "help"];
 const ALIASES = {
     kids: "students",
     tenants: "find-school",
@@ -226,6 +226,8 @@ export function parseCliArgs(argv) {
                 return parsed("remove", args.slice(1));
             noMore(args);
             return parsed(null);
+        case "logout":
+            return parsed(null, args);
         case "config":
             if (args[0] !== "clear" || args.length > 1)
                 throw usage('Expected "wilma config clear".');

package/dist/cli-help.js

@@ -68,9 +68,15 @@ const COMMAND_HELP = {
     },
     accounts: {
         usage: ["wilma accounts", "wilma accounts remove <number|Wilma name|username>"],
-        about: "Saved Wilma logins, numbered (one per Wilma the children use); remove one.",
+        about: "Saved Wilma logins, numbered (one per Wilma the children use). `remove` deletes one and ends its Wilma session; the other logins keep theirs.",
         examples: ["wilma accounts", "wilma accounts remove 2"],
     },
+    logout: {
+        usage: ["wilma logout [<number|Wilma name|username>]"],
+        about: "End WilmAI's Wilma session, as Wilma's own Log out does, so you can use Wilma in the browser (Wilma allows one session per account). Every saved login by default, or one by its number from `wilma accounts`. The logins stay saved: the next command logs in again, and that ends your Wilma session in the browser. To delete the logins as well, use `wilma config clear`.",
+        examples: ["wilma logout", "wilma logout 2"],
+        output: '{ status: "ok", logins: [{ wilma, username, session: "ended" | "none" }], hint }. "none": there was no open session to end.',
+    },
     "find-school": {
         usage: ["wilma find-school <city or school>"],
         about: "Find a Wilma address. Most city schools share their city's Wilma (big cities don't list each school); colleges, private schools and many small municipalities' schools have their own.",
@@ -98,6 +104,7 @@ const OVERVIEW = [
     ["students", "the children"],
     ["login", "log in (opens a page in the browser)"],
     ["accounts", "saved logins; accounts remove <n>"],
+    ["logout", "end WilmAI's Wilma session (the logins stay saved)"],
     ["find-school <query>", "find a Wilma address by city or school"],
     ["mcp", "MCP server for AI assistants"],
     ["update", "update the CLI"],

package/dist/cli-output.js

@@ -8,7 +8,8 @@ function formatContent(value) {
     const lines = value
         .replace(/\r/g, "")
         .split("\n")
-        .map((line) => line.trim())
+        // Leading spaces stay: they indent nested list items.
+        .map((line) => line.trimEnd())
         .filter((line, index, arr) => line !== "" || arr[index - 1] !== "");
     return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }

package/dist/index.js

@@ -8,8 +8,8 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { APIError, AuthenticationError, MfaRequiredError, NetworkError, WilmaClient, listTenants, } from "@wilm-ai/wilma-client";
 import { clearConfig, getConfigPath, loadConfig, obfuscateSecret, revealSecret, saveConfig } from "./config.js";
-import { WilmaAccess, WilmaAiError, adoptSession, flushSessions, useSessionStore, } from "./agent-data.js";
-import { createAccess } from "./access.js";
+import { WilmaAccess, WilmaAiError, adoptSession, flushSessions, forgetSession, logoutSession, useSessionStore, } from "./agent-data.js";
+import { createAccess, logoutAccounts } from "./access.js";
 import { parseCliArgs } from "./cli-args.js";
 import { commandHelp, generalHelp } from "./cli-help.js";
 import { compactText, formatText, messageLine, newsLine } from "./cli-output.js";
@@ -117,6 +117,9 @@ async function runCommand(argv) {
         case "accounts":
             await handleAccounts(action, args, out);
             return;
+        case "logout":
+            await handleLogout(args.join(" "), flags, out);
+            return;
         case "find-school":
             await handleFindSchool(args.join(" "), out);
             return;
@@ -680,24 +683,18 @@ const HEADLESS_LOGIN_HELP = [
 async function handleAccounts(action, args, out) {
     const config = await loadConfig();
     if (action === "remove") {
-        const target = args.join(" ").trim().toLowerCase();
-        if (!target)
-            throw new WilmaAiError("invalid_argument", "Which login? Use the number from `wilma accounts`, the Wilma name or the username.");
-        const byNumber = /^\d+$/.test(target) ? config.profiles[Number(target) - 1] : undefined;
-        const matches = byNumber
-            ? [byNumber]
-            : config.profiles.filter((p) => [p.tenantName ?? "", p.tenantUrl, p.username].some((v) => v.toLowerCase() === target));
-        if (matches.length !== 1) {
-            throw new WilmaAiError(matches.length ? "ambiguous_account" : "unknown_account", matches.length ? `"${target}" matches several logins; use its number.` : `No saved login matches "${target}".`);
-        }
-        const removed = matches[0];
+        const removed = findSavedLogin(config.profiles, args.join(" "));
         config.profiles = config.profiles.filter((p) => p.id !== removed.id);
         if (config.lastProfileId === removed.id)
             config.lastProfileId = config.profiles[0]?.id ?? null;
         await saveConfig(config);
-        await clearSessions();
-        const result = { status: "removed", wilma: removed.tenantName ?? removed.tenantUrl, username: removed.username };
-        out.data(result, () => `Removed ${removed.username} @ ${result.wilma}.`);
+        const session = await endRemovedSession(removed);
+        const result = { status: "removed", wilma: removed.tenantName ?? removed.tenantUrl, username: removed.username, ...session };
+        out.data(result, () => session.session === "ended"
+            ? `Removed ${removed.username} @ ${result.wilma} and ended its Wilma session.`
+            : session.session === "not_ended"
+                ? `Removed ${removed.username} @ ${result.wilma}. Its Wilma session couldn't be ended (${session.message}); Wilma ends it when it expires.`
+                : `Removed ${removed.username} @ ${result.wilma}.`);
         return;
     }
     const accounts = config.profiles.map((p, i) => ({
@@ -715,6 +712,64 @@ async function handleAccounts(action, args, out) {
         ].join("\n")
         : "No saved Wilma logins. Run `wilma login`.");
 }
+/**
+ * End a removed login's Wilma session and forget it; the other logins keep
+ * theirs. The login is removed even when Wilma can't be reached: its saved
+ * session is forgotten anyway, and Wilma ends the session when it expires.
+ */
+async function endRemovedSession(removed) {
+    const password = revealSecret(removed.passwordObfuscated);
+    if (!password)
+        return { session: "none" };
+    const profile = { baseUrl: removed.tenantUrl, username: removed.username, password };
+    try {
+        return { session: (await logoutSession(profile)) ? "ended" : "none" };
+    }
+    catch (err) {
+        await forgetSession(profile);
+        return { session: "not_ended", message: err instanceof Error ? err.message : String(err) };
+    }
+}
+/** A saved login by its number in `wilma accounts`, its Wilma's name or address, or its username. */
+function findSavedLogin(profiles, rawTarget) {
+    const target = rawTarget.trim().toLowerCase();
+    if (!target)
+        throw new WilmaAiError("invalid_argument", "Which login? Use the number from `wilma accounts`, the Wilma name or the username.");
+    const byNumber = /^\d+$/.test(target) ? profiles[Number(target) - 1] : undefined;
+    const matches = byNumber
+        ? [byNumber]
+        : profiles.filter((p) => [p.tenantName ?? "", p.tenantUrl, p.username].some((v) => v.toLowerCase() === target));
+    if (matches.length !== 1) {
+        throw new WilmaAiError(matches.length ? "ambiguous_account" : "unknown_account", matches.length ? `"${target}" matches several logins; use its number.` : `No saved login matches "${target}".`);
+    }
+    return matches[0];
+}
+/**
+ * End WilmAI's Wilma sessions so the parent can use Wilma in the browser:
+ * every login commands use, or one saved login. The logins stay saved.
+ */
+async function handleLogout(target, flags, out) {
+    if (flags.student) {
+        throw new WilmaAiError("invalid_argument", "A Wilma session belongs to a login, not to one child. Use `wilma logout <number>` with the number from `wilma accounts`, or no number for every login.");
+    }
+    const config = await loadConfig();
+    // The logins commands use (the environment's, or every saved one); a picked
+    // login is one of the saved ones, numbered as in `wilma accounts`.
+    let accounts = await resolveAccounts(config, target ? {} : process.env);
+    if (target) {
+        const login = findSavedLogin(config.profiles, target);
+        const account = (p) => `${normalizeTenantUrl(p.tenantUrl)}|${p.username.toLowerCase()}`;
+        accounts = accounts.filter((a) => a.stored && account(a.stored) === account(login));
+    }
+    const result = await logoutAccounts(accounts);
+    out.data(result, () => result.logins.length
+        ? [
+            ...result.logins.map((l) => `${l.session === "ended" ? "Logged out" : "No open session"}: ${l.username} @ ${l.wilma}`),
+            "",
+            "The logins stay saved. The next wilma command logs in again, and that ends your Wilma session in the browser.",
+        ].join("\n")
+        : result.hint);
+}
 async function readStdin() {
     const chunks = [];
     for await (const chunk of process.stdin)

package/dist/login-server.d.ts

@@ -14,9 +14,23 @@ export interface LoginServer {
  * on different Wilmas can add another login on the same page; it closes when
  * the parent presses Done or after 15 idle minutes.
  */
+/**
+ * The assistant app that asked for the login (by the name it gives when it
+ * connects to the MCP server), named in the page's intro so the parent can
+ * connect the page to what they just did.
+ */
+export type OpenedBy = {
+    app: string;
+};
+/** A plain app name from the name an MCP client reports, or undefined if unknown. */
+export declare function appName(client?: {
+    name?: string;
+    title?: string;
+}): string | undefined;
 export declare function startLoginServer(opts?: {
     timeoutMs?: number;
     onSaved?: (profile: StoredProfile) => void;
+    openedBy?: OpenedBy;
 }): Promise<LoginServer>;
 export type BrowserOpenResult = "opened" | "skipped" | "headless";
 /** Best-effort: open a URL in the user's default browser. */
@@ -28,6 +42,7 @@ export interface LoginPageOptions {
     apiBase: string;
     /** Shown in the privacy note under the form. */
     configPath?: string;
+    openedBy?: OpenedBy;
 }
 /** The login page. The login API answers {status: "ok", students, accounts}. */
 export declare function renderLoginPage(opts: LoginPageOptions): string;

package/dist/login-server.js

@@ -16,13 +16,25 @@ function accountsSummary(profiles) {
         students: (p.students ?? []).map((s) => s.name),
     }));
 }
-/**
- * Serve a one-time login page on 127.0.0.1. The parent picks their school's
- * Wilma, logs in, and the verified login is saved to the local config file —
- * the password never passes through an agent's chat. Families with children
- * on different Wilmas can add another login on the same page; it closes when
- * the parent presses Done or after 15 idle minutes.
- */
+/** A plain app name from the name an MCP client reports, or undefined if unknown. */
+export function appName(client) {
+    const raw = `${client?.title ?? ""} ${client?.name ?? ""}`.toLowerCase();
+    if (raw.includes("claude-code") || raw.includes("claude code"))
+        return "Claude Code";
+    if (raw.includes("claude"))
+        return "Claude";
+    if (raw.includes("codex"))
+        return "Codex";
+    if (raw.includes("chatgpt") || raw.includes("openai"))
+        return "ChatGPT";
+    if (raw.includes("cursor"))
+        return "Cursor";
+    if (raw.includes("openclaw"))
+        return "OpenClaw";
+    // Another app: its own display name, if it gave one.
+    const title = client?.title?.trim();
+    return title && title.length <= 40 ? title : undefined;
+}
 export async function startLoginServer(opts = {}) {
     const token = randomBytes(18).toString("base64url");
     const nonce = randomBytes(16).toString("base64");
@@ -64,7 +76,7 @@ export async function startLoginServer(opts = {}) {
                     "base-uri 'none'",
                 ].join("; "),
             });
-            res.end(renderLoginPage({ nonce, apiBase: `${base}/api`, configPath: getConfigPath() }));
+            res.end(renderLoginPage({ nonce, apiBase: `${base}/api`, configPath: getConfigPath(), openedBy: opts.openedBy }));
             return;
         }
         if (url.pathname === `${base}/api/tenants` && req.method === "GET") {
@@ -260,7 +272,18 @@ export function renderLoginPage(opts) {
             tooMany: "Too many attempts. Close this tab and start again from your assistant.",
             missing: "Pick your school's Wilma and fill in both fields.",
             expired: "This login page is no longer active. Start the login again from your assistant, or run wilma login.",
-            privacy: "Your login is saved only on this computer, in {path}. WilmAI has no server; it talks only to your school's Wilma.",
+            privacy: "Your login is saved only on this computer, in {path}, readable only by your user account. To remove it, run wilma config clear or delete that file.",
+            introApp: "{app} asked to connect to your Wilma. Log in once, and {app} can then check schedules, homework, exams, messages and news for you.",
+            trustLocalTitle: "On your own computer",
+            trustLocal: "This page isn't a website. It runs on this computer (that's what 127.0.0.1 in the address bar means), and WilmAI has no server.",
+            trustWilmaTitle: "Only to your school's Wilma",
+            trustWilma: "Your password goes from this computer straight to your school's Wilma. Your assistant never sees it.",
+            trustWilmaHost: "Your password goes from this computer straight to {host}. Your assistant never sees it.",
+            trustReadTitle: "The same information you see",
+            trustRead: "WilmAI reads schedules, messages, news and the rest just as you see them in Wilma.",
+            sentTo: "Sent only to {host}",
+            learnMore: "How WilmAI handles your login",
+            sourceCode: "Source code",
             disclaimer: "WilmAI is an independent open-source project, not affiliated with Visma or the Wilma service.",
         },
         fi: {
@@ -293,7 +316,18 @@ export function renderLoginPage(opts) {
             tooMany: "Liian monta yritystä. Sulje välilehti ja aloita uudelleen avustajasi kautta.",
             missing: "Valitse koulusi Wilma ja täytä molemmat kentät.",
             expired: "Tämä kirjautumissivu ei ole enää käytössä. Aloita kirjautuminen uudelleen avustajasi kautta tai komennolla wilma login.",
-            privacy: "Kirjautumistietosi tallennetaan vain tälle tietokoneelle, tiedostoon {path}. WilmAI:lla ei ole palvelinta; se on yhteydessä vain koulusi Wilmaan.",
+            privacy: "Kirjautumistietosi tallennetaan vain tälle tietokoneelle, tiedostoon {path}, jota vain sinun käyttäjätilisi voi lukea. Voit poistaa ne komennolla wilma config clear tai poistamalla tiedoston.",
+            introApp: "{app} pyysi yhteyttä Wilmaasi. Kirjaudu kerran, niin {app} voi sen jälkeen tarkistaa lukujärjestykset, läksyt, kokeet, viestit ja tiedotteet puolestasi.",
+            trustLocalTitle: "Omalla koneellasi",
+            trustLocal: "Tämä sivu ei ole verkkosivusto. Se toimii tällä koneella (sitä osoiterivin 127.0.0.1 tarkoittaa), eikä WilmAI:lla ole palvelinta.",
+            trustWilmaTitle: "Vain koulusi Wilmaan",
+            trustWilma: "Salasanasi lähtee tältä koneelta suoraan koulusi Wilmaan. Avustajasi ei näe sitä.",
+            trustWilmaHost: "Salasanasi lähtee tältä koneelta suoraan osoitteeseen {host}. Avustajasi ei näe sitä.",
+            trustReadTitle: "Samat tiedot kuin sinulla",
+            trustRead: "WilmAI lukee lukujärjestykset, viestit, tiedotteet ja muut tiedot samoin kuin näet ne Wilmassa.",
+            sentTo: "Lähetetään vain osoitteeseen {host}",
+            learnMore: "Miten WilmAI käsittelee kirjautumisen (englanniksi)",
+            sourceCode: "Lähdekoodi",
             disclaimer: "WilmAI on itsenäinen avoimen lähdekoodin projekti, eikä se liity Vismaan tai Wilma-palveluun.",
         },
     };
@@ -310,9 +344,14 @@ export function renderLoginPage(opts) {
   @media (prefers-color-scheme: dark) { :root { --ink:#eef2f3; --muted:#a8b5bb; --paper:#141c21; --line:#2c3a42; --card:#1b252b; --err:#ff8a80; } }
   * { box-sizing:border-box; }
   body { margin:0; background:var(--paper); color:var(--ink); font:16px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; }
-  main { max-width:440px; margin:0 auto; padding:40px 16px 48px; }
+  main { max-width:920px; margin:0 auto; padding:32px 16px 48px; }
+  .layout { display:grid; grid-template-columns:minmax(0, 1fr) minmax(0, 1fr); gap:24px 48px; align-items:start; }
+  .layout .card { margin:0 0 16px; }
+  .foot { max-width:560px; margin-top:28px; }
+  @media (max-width:760px) { main { max-width:480px; } .layout { grid-template-columns:minmax(0, 1fr); } }
   h1 { font-size:28px; line-height:1.2; margin:0 0 8px; }
   h1 mark { background:linear-gradient(transparent 55%, var(--yellow) 55%); color:inherit; padding:0 2px; }
+  @media (prefers-color-scheme: dark) { h1 mark { background:linear-gradient(transparent 60%, rgba(255,216,77,.4) 60%); } }
   p { margin:0 0 16px; }
   .muted { color:var(--muted); font-size:14px; }
   .card { background:var(--card); border:1px solid var(--line); border-radius:12px; padding:20px; margin:20px 0; }
@@ -343,13 +382,41 @@ export function renderLoginPage(opts) {
   .add-hint { margin-top:8px; }
   .error { color:var(--err); margin-top:12px; }
   .done h2 { margin:0 0 8px; }
+  .top { display:flex; justify-content:space-between; align-items:center; gap:12px; margin-bottom:28px; }
+  .brand { font-weight:800; font-size:18px; letter-spacing:-0.01em; }
+  .lang { display:flex; gap:4px; }
+  .lang button { font:inherit; font-size:13px; padding:3px 10px; border-radius:999px; border:1px solid var(--line); background:transparent; color:var(--muted); cursor:pointer; }
+  .lang button[aria-pressed="true"] { background:var(--yellow); border-color:var(--yellow); color:#1b2b34; font-weight:700; }
+  .trust { list-style:none; margin:20px 0 0; padding:0; display:flex; flex-direction:column; gap:12px; }
+  .trust li { display:flex; gap:12px; align-items:flex-start; }
+  .trust svg { flex:none; width:22px; height:22px; margin-top:1px; fill:none; stroke:var(--teal); stroke-width:1.8; stroke-linecap:round; stroke-linejoin:round; }
+  .trust strong { display:block; font-size:15px; line-height:1.35; }
+  .trust span { display:block; font-size:14px; line-height:1.45; color:var(--muted); }
+  .sent-to { font-size:13px; color:var(--muted); margin:6px 0 0; }
+  .links a { color:var(--teal); }
   [hidden] { display:none !important; }
 </style>
 </head>
 <body>
 <main>
+  <header class="top">
+    <span class="brand">WilmAI</span>
+    <span class="lang" role="group" aria-label="Kieli / Language">
+      <button type="button" id="lang-fi" lang="fi">Suomi</button>
+      <button type="button" id="lang-en" lang="en">English</button>
+    </span>
+  </header>
+  <div class="layout">
+  <div class="about">
   <h1 id="heading"></h1>
   <p id="intro"></p>
+  <ul class="trust">
+    <li><svg viewBox="0 0 24 24" aria-hidden="true"><rect x="3" y="4" width="18" height="12" rx="2"/><path d="M8 20h8M12 16v4"/></svg><div><strong id="trust-local-title"></strong><span id="trust-local"></span></div></li>
+    <li><svg viewBox="0 0 24 24" aria-hidden="true"><rect x="5" y="11" width="14" height="9" rx="2"/><path d="M8 11V8a4 4 0 0 1 8 0v3"/></svg><div><strong id="trust-wilma-title"></strong><span id="trust-wilma"></span></div></li>
+    <li><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7S2 12 2 12z"/><circle cx="12" cy="12" r="3"/></svg><div><strong id="trust-read-title"></strong><span id="trust-read"></span></div></li>
+  </ul>
+  </div>
+  <div class="forms">
   <section class="card" id="form-card">
     <div id="school-pick">
       <label for="school" id="school-label"></label>
@@ -367,6 +434,7 @@ export function renderLoginPage(opts) {
     <input id="username" autocomplete="username" autocapitalize="none" spellcheck="false">
     <label for="password" id="password-label"></label>
     <input id="password" type="password" autocomplete="current-password">
+    <p class="sent-to" id="sent-to" hidden></p>
     <div id="mfa" hidden>
       <label id="mfa-title"></label>
       <p class="muted" id="mfa-body"></p>
@@ -388,37 +456,75 @@ export function renderLoginPage(opts) {
     <h2 id="finished-title"></h2>
     <p id="finished-body"></p>
   </section>
+  </div>
+  </div>
+  <div class="foot">
   <p class="muted" id="privacy"></p>
+  <p class="muted links"><a id="learn-more" href="https://github.com/aikarjal/wilmai#credentials--privacy" target="_blank" rel="noreferrer"></a> · <a id="source-code" href="https://github.com/aikarjal/wilmai" target="_blank" rel="noreferrer"></a></p>
   <p class="muted" id="disclaimer"></p>
+  </div>
 </main>
 <script nonce="${nonce}">
 (() => {
   const STRINGS = ${jsonForScript(strings)};
   const API = ${jsonForScript(opts.apiBase)};
   const CONFIG_PATH = ${jsonForScript(opts.configPath ?? "")};
-  const lang = (navigator.language || "en").toLowerCase().startsWith("fi") ? "fi" : "en";
-  const t = STRINGS[lang];
-  document.documentElement.lang = lang;
-  document.title = t.title;
+  const OPENED_BY = ${jsonForScript(opts.openedBy ?? null)};
+  let lang = (navigator.language || "en").toLowerCase().startsWith("fi") ? "fi" : "en";
+  let t = STRINGS[lang];
+  let tenant = null;
+  let timer = null;
+  let seq = 0;
+  let shownAccounts = null;
   const $ = (id) => document.getElementById(id);
   const text = (id, value) => { $(id).textContent = value; };
-  text("heading", ""); $("heading").append(t.heading.split(" ").slice(0, -1).join(" ") + " ");
-  const mark = document.createElement("mark"); mark.textContent = t.heading.split(" ").slice(-1)[0]; $("heading").append(mark);
-  text("intro", t.intro); text("school-label", t.school); text("school-label-2", t.school);
-  $("school").placeholder = t.schoolHint; text("no-results", t.noResults); text("change", t.change);
-  text("school-help", t.schoolHelp);
+  const hostOf = (url) => { try { return new URL(url).host; } catch { return url; } };
+
+  // Every text on the page, in the chosen language (the switch at the top re-runs this).
+  function applyText() {
+    t = STRINGS[lang];
+    document.documentElement.lang = lang;
+    document.title = t.title;
+    $("heading").replaceChildren(t.heading.split(" ").slice(0, -1).join(" ") + " ");
+    const mark = document.createElement("mark"); mark.textContent = t.heading.split(" ").slice(-1)[0]; $("heading").append(mark);
+    text("intro", OPENED_BY ? t.introApp.split("{app}").join(OPENED_BY.app) : t.intro);
+    text("trust-local-title", t.trustLocalTitle); text("trust-local", t.trustLocal);
+    text("trust-wilma-title", t.trustWilmaTitle);
+    text("trust-read-title", t.trustReadTitle); text("trust-read", t.trustRead);
+    text("school-label", t.school); text("school-label-2", t.school);
+    $("school").placeholder = t.schoolHint; text("no-results", t.noResults); text("change", t.change);
+    text("school-help", t.schoolHelp);
+    text("username-label", t.username); text("password-label", t.password);
+    text("mfa-title", t.mfaTitle); text("mfa-body", t.mfaBody); text("mfa-label", t.mfaLabel); text("mfa-help", t.mfaHelp);
+    if (!$("submit").disabled) text("submit", t.submit);
+    text("done-title", t.doneTitle);
+    text("finish", t.finish); text("add-another", t.addAnother); text("add-hint", t.addAnotherHint);
+    text("finished-title", t.finishedTitle); text("finished-body", t.finishedBody);
+    text("privacy", t.privacy.replace("{path}", CONFIG_PATH));
+    text("learn-more", t.learnMore); text("source-code", t.sourceCode);
+    text("disclaimer", t.disclaimer);
+    for (const code of ["fi", "en"]) $("lang-" + code).setAttribute("aria-pressed", String(code === lang));
+    showHost();
+    if (shownAccounts) renderAccounts(shownAccounts);
+  }
+
+  // Where the password goes, once the parent has picked their Wilma.
+  function showHost() {
+    const host = tenant ? hostOf(tenant.url) : "";
+    text("trust-wilma", host ? t.trustWilmaHost.replace("{host}", host) : t.trustWilma);
+    $("sent-to").hidden = !host;
+    if (host) text("sent-to", t.sentTo.replace("{host}", host));
+  }
+
+  for (const code of ["fi", "en"]) $("lang-" + code).addEventListener("click", () => { lang = code; applyText(); });
   for (const city of ["Helsinki", "Espoo", "Tampere", "Vantaa", "Oulu", "Turku", "Jyväskylä"]) {
     const b = document.createElement("button"); b.type = "button"; b.textContent = city;
     b.addEventListener("click", () => { $("school").value = city; search(city).catch(() => showError(t.expired)); $("school").focus(); });
     $("chips").append(b);
   }
-  text("username-label", t.username); text("password-label", t.password);
-  text("mfa-title", t.mfaTitle); text("mfa-body", t.mfaBody); text("mfa-label", t.mfaLabel); text("mfa-help", t.mfaHelp);
-  text("submit", t.submit); text("done-title", t.doneTitle);
-  text("finish", t.finish); text("add-another", t.addAnother); text("add-hint", t.addAnotherHint);
-  text("finished-title", t.finishedTitle); text("finished-body", t.finishedBody);
 
   function renderAccounts(accounts) {
+    shownAccounts = accounts;
     const box = $("accounts"); box.replaceChildren();
     const intro = document.createElement("p"); intro.textContent = t.doneIntro; box.append(intro);
     for (const account of accounts) {
@@ -434,7 +540,7 @@ export function renderLoginPage(opts) {
   }
 
   $("add-another").addEventListener("click", () => {
-    tenant = null;
+    tenant = null; shownAccounts = null; showHost();
     for (const id of ["school", "username", "password", "totp"]) $(id).value = "";
     render([]); showError("");
     $("mfa").hidden = true; $("school-chosen").hidden = true; $("school-pick").hidden = false;
@@ -457,21 +563,16 @@ export function renderLoginPage(opts) {
     }
     $("done").hidden = true; $("finished").hidden = false;
   });
-  text("privacy", t.privacy.replace("{path}", CONFIG_PATH)); text("disclaimer", t.disclaimer);
-
-  let tenant = null;
-  let timer = null;
-  let seq = 0;
   const showError = (msg) => { const el = $("error"); el.textContent = msg; el.hidden = !msg; };
 
   function choose(t2) {
     tenant = t2;
-    text("chosen-name", t2.name || t2.url); text("chosen-url", t2.url);
+    text("chosen-name", t2.name || t2.url); text("chosen-url", t2.url); showHost();
     $("school-pick").hidden = true; $("school-chosen").hidden = false;
     $("username").focus();
   }
   $("change").addEventListener("click", () => {
-    tenant = null; $("school-chosen").hidden = true; $("school-pick").hidden = false; $("school").focus();
+    tenant = null; showHost(); $("school-chosen").hidden = true; $("school-pick").hidden = false; $("school").focus();
   });
 
   async function search(q) {
@@ -565,6 +666,7 @@ export function renderLoginPage(opts) {
       btn.disabled = false; btn.textContent = t.submit;
     }
   }
+  applyText();
   $("school").focus();
 })();
 </script>

package/dist/mcp-tools.d.ts

@@ -1,7 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import type { FetchedAttachment, WilmaAccess } from "./agent-data.js";
-export declare const INSTRUCTIONS = "Read-only access to Finland's Wilma school system for a parent/guardian.\n- Start with wilma_summary: today's and tomorrow's lessons, upcoming exams, recent homework, news and messages for every child in one call.\n- Tools cover all children by default; pass \"student\" (name or student number) to narrow to one child.\n- Wilma content is usually in Finnish. Answer in the user's language and translate as needed. Write dates the way that language does: Finnish \"ke 7.10.\" (with the final period), English \"Wed 7 Oct\".\n- Message and news lists return ids; use wilma_read_message / wilma_read_news for full text. Bulletins can link attachments; fetch them with wilma_get_news_attachment.\n- Teachers' feedback (\"forgot books\", \"did well\") and absences are lesson notes: wilma_lesson_notes for recent days, wilma_lesson_notes_summary for counts. Course and report-card grades are in wilma_gradebook.\n- If a tool says the user isn't logged in, relay the login link or instructions to the user exactly; never ask the user to type their Wilma password into the chat.\n- If a result ends with an \"Update note\", answer the question first, then pass the note on in one sentence.";
+export declare const INSTRUCTIONS = "Read-only access to Finland's Wilma school system for a parent/guardian.\n- Start with wilma_summary: today's and tomorrow's lessons, upcoming exams, recent homework, news and messages for every child in one call.\n- Tools cover all children by default; pass \"student\" (name or student number) to narrow to one child.\n- Wilma content is usually in Finnish. Answer in the user's language and translate as needed. Write dates the way that language does: Finnish \"ke 7.10.\" (with the final period), English \"Wed 7 Oct\".\n- Message and news lists return ids; use wilma_read_message / wilma_read_news for full text. Bulletins can link attachments; fetch them with wilma_get_news_attachment.\n- Teachers' feedback (\"forgot books\", \"did well\") and absences are lesson notes: wilma_lesson_notes for recent days, wilma_lesson_notes_summary for counts. Course and report-card grades are in wilma_gradebook.\n- If a tool says the user isn't logged in, relay the login link or instructions to the user exactly; never ask the user to type their Wilma password into the chat.\n- Wilma allows one session per account, so each WilmAI login logs the user out of Wilma in their browser. If they want to use Wilma in the browser, call wilma_logout and then call Wilma tools only when they ask again.\n- If a result ends with an \"Update note\", answer the question first, then pass the note on in one sentence.";
 export declare const READ_ONLY: {
     readonly readOnlyHint: true;
     readonly destructiveHint: false;

package/dist/mcp-tools.js

@@ -12,6 +12,7 @@ export const INSTRUCTIONS = `Read-only access to Finland's Wilma school system f
 - Message and news lists return ids; use wilma_read_message / wilma_read_news for full text. Bulletins can link attachments; fetch them with wilma_get_news_attachment.
 - Teachers' feedback ("forgot books", "did well") and absences are lesson notes: wilma_lesson_notes for recent days, wilma_lesson_notes_summary for counts. Course and report-card grades are in wilma_gradebook.
 - If a tool says the user isn't logged in, relay the login link or instructions to the user exactly; never ask the user to type their Wilma password into the chat.
+- Wilma allows one session per account, so each WilmAI login logs the user out of Wilma in their browser. If they want to use Wilma in the browser, call wilma_logout and then call Wilma tools only when they ask again.
 - If a result ends with an "Update note", answer the question first, then pass the note on in one sentence.`;
 export const READ_ONLY = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 const INLINE_ATTACHMENT_LIMIT = 10 * 1024 * 1024;

package/dist/mcp.js

@@ -5,12 +5,12 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { AuthenticationError } from "@wilm-ai/wilma-client";
 import { useSessionStore } from "./agent-data.js";
-import { fileSessionStore } from "./session-store.js";
-import { createAccess } from "./access.js";
+import { fileSessionStore, nameSessionOwner } from "./session-store.js";
+import { createAccess, logoutAccounts } from "./access.js";
 import { loadConfig } from "./config.js";
 import { ENV_VARS, isMfaFailure, resolveAccounts } from "./credentials.js";
 import { createUniqueDownloadFile } from "./downloads.js";
-import { openBrowser, startLoginServer } from "./login-server.js";
+import { appName, openBrowser, startLoginServer } from "./login-server.js";
 import { z } from "zod";
 import { INSTRUCTIONS, READ_ONLY, json, registerWilmaTools, textResult } from "./mcp-tools.js";
 import { searchTenants } from "./tenant-search.js";
@@ -23,6 +23,8 @@ const SECRET_SETTINGS_HINT = [
     "Never ask the user to type their Wilma password into the chat.",
 ].join("\n");
 let loginServerPromise = null;
+/** The running server, so the login page can name the app that asked for it. */
+let mcpServer = null;
 /** One login page at a time. Parallel tool calls share it; an explicit wilma_login starts a fresh one. */
 async function ensureLoginServer(fresh) {
     if (fresh && loginServerPromise) {
@@ -31,7 +33,8 @@ async function ensureLoginServer(fresh) {
     }
     if (loginServerPromise)
         return { server: await loginServerPromise, created: false };
-    const pending = startLoginServer().then((server) => {
+    const app = appName(mcpServer?.server.getClientVersion());
+    const pending = startLoginServer(app ? { openedBy: { app } } : {}).then((server) => {
         server.result.finally(() => {
             if (loginServerPromise === pending)
                 loginServerPromise = null;
@@ -158,6 +161,20 @@ function createWilmaMcpServer(version) {
         inputSchema: {},
         annotations: { title: "Log in to Wilma", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     }, async () => startBrowserLogin(true));
+    server.registerTool("wilma_logout", {
+        title: "Log out of Wilma",
+        description: "End WilmAI's Wilma session, as Wilma's own Log out does. Wilma allows one session per account, so use this when the user wants to use Wilma in their browser or asks to log out. The login stays saved: the next Wilma tool call logs in again, and that ends the user's session in the browser, so don't call other Wilma tools afterwards unless the user asks.",
+        inputSchema: {},
+        annotations: { title: "Log out of Wilma", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, async () => {
+        try {
+            return json(await logoutAccounts(await resolveAccounts(await loadConfig())));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return textResult(["Couldn't log out of Wilma; an open session was kept, so this can be tried again.", message].join("\n"), true);
+        }
+    });
     return server;
 }
 export async function runMcpServer(version) {
@@ -165,10 +182,12 @@ export async function runMcpServer(version) {
     console.log = (...args) => console.error(...args);
     console.info = (...args) => console.error(...args);
     // Share saved sessions with the CLI: no login per process, no extra codes.
+    nameSessionOwner("mcp");
     useSessionStore(fileSessionStore);
     // Checked once a day at most; npx already runs the newest version.
     if (updateChecksEnabled())
         updateCheck = startUpdateCheck();
     const server = createWilmaMcpServer(version);
+    mcpServer = server;
     await server.connect(new StdioServerTransport());
 }

package/dist/session-store.d.ts

@@ -1,7 +1,16 @@
 export interface SessionStore {
     load(key: string): Promise<string | null>;
     save(key: string, state: string): Promise<void>;
+    /** Forget one session (after logging out). */
+    remove(key: string): Promise<void>;
 }
+/** Name this program in the sessions it saves (the MCP server says "mcp"). */
+export declare function nameSessionOwner(name: string): void;
 export declare const fileSessionStore: SessionStore;
-/** Forget every saved session (after removing logins or clearing the config). */
+/** When one login's session was saved, and by which program (null when there's none to try). */
+export declare function sessionInfo(key: string): Promise<{
+    savedAt: number;
+    by: string | null;
+} | null>;
+/** Forget every saved session (after clearing the config). */
 export declare function clearSessions(): Promise<void>;

package/dist/session-store.js

@@ -16,6 +16,11 @@ import { getConfigPath } from "./config.js";
  */
 /** A session older than this is not tried (Wilma ends idle sessions anyway). */
 const SESSION_TTL_MS = 6 * 60 * 60 * 1000;
+let savedBy = "cli";
+/** Name this program in the sessions it saves (the MCP server says "mcp"). */
+export function nameSessionOwner(name) {
+    savedBy = name;
+}
 function sessionsPath() {
     return resolve(dirname(getConfigPath()), "wilmai-sessions.json");
 }
@@ -46,16 +51,35 @@ export const fileSessionStore = {
             if (now - entry.savedAt > SESSION_TTL_MS)
                 delete all[k];
         }
-        all[key] = { state, savedAt: now };
-        const path = sessionsPath();
-        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-        // Temp file + rename: a parallel command never reads half a file.
-        const tmp = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
-        await writeFile(tmp, JSON.stringify(all), { encoding: "utf-8", mode: 0o600 });
-        await rename(tmp, path);
+        all[key] = { state, savedAt: now, by: savedBy };
+        await writeAll(all);
+    },
+    async remove(key) {
+        const all = await readAll();
+        if (!(key in all))
+            return;
+        delete all[key];
+        await writeAll(all);
     },
 };
-/** Forget every saved session (after removing logins or clearing the config). */
+async function writeAll(all) {
+    const path = sessionsPath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    // Temp file + rename: a parallel command never reads half a file.
+    const tmp = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    await writeFile(tmp, JSON.stringify(all), { encoding: "utf-8", mode: 0o600 });
+    await rename(tmp, path);
+}
+/** When one login's session was saved, and by which program (null when there's none to try). */
+export async function sessionInfo(key) {
+    if (process.env.WILMAI_NO_SESSION_CACHE === "1")
+        return null;
+    const entry = (await readAll())[key];
+    if (!entry || typeof entry.state !== "string" || Date.now() - entry.savedAt > SESSION_TTL_MS)
+        return null;
+    return { savedAt: entry.savedAt, by: typeof entry.by === "string" ? entry.by : null };
+}
+/** Forget every saved session (after clearing the config). */
 export async function clearSessions() {
     await rm(sessionsPath(), { force: true });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wilm-ai/wilma-cli",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "Read your children's Wilma (Finnish school system) from the terminal or an AI assistant: schedule, homework, exams, messages and news.",
   "license": "MIT",
   "repository": {
@@ -21,7 +21,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "lint": "tsc -p tsconfig.json --noEmit",
-    "test": "pnpm --filter @wilm-ai/wilma-client build && pnpm run build && node test/news-resources.mjs && node test/mcp-login.mjs && node test/mfa.mjs && node test/audit.mjs && node test/update-notice.mjs",
+    "test": "pnpm --filter @wilm-ai/wilma-client build && pnpm run build && node test/news-resources.mjs && node test/mcp-login.mjs && node test/mfa.mjs && node test/logout.mjs && node test/shared-session.mjs && node test/audit.mjs && node test/update-notice.mjs",
     "start": "node dist/index.js",
     "prepack": "pnpm --filter @wilm-ai/wilma-client build && pnpm --filter @wilm-ai/wilma-cli build",
     "test:live": "tsc -p tsconfig.json && node test/live.spec.mjs",
@@ -30,7 +30,7 @@
   "dependencies": {
     "@inquirer/prompts": "^5.3.8",
     "@modelcontextprotocol/sdk": "^1.32.0",
-    "@wilm-ai/wilma-client": "^1.6.1",
+    "@wilm-ai/wilma-client": "^1.7.0",
     "zod": "^4.1.0"
   },
   "devDependencies": {