wizards 0.3.8 → 0.4.1

package/README.md

@@ -44,37 +44,50 @@ A wizard in use: it asks on one page, then on the next, and ends with the result
   <img src="docs/assets/wizard.png" alt="A wizard in use on a phone, three pictures: which week and how many children, what is on the table, and the finished weekly plan with PDF, PNG and sharing">
 </p>
 
-## Install
+## Get started
 
-On macOS or Linux, in a terminal:
+Create an account at [engenty.ai](https://engenty.ai): it is in a closed beta, so "Get started"
+takes your e-mail for an invitation, or your invitation code. Signed in, the studio asks who
+your team is, reads your website into your space, takes first documents, and you build your
+first wizard in the browser. Links run day and night on the team's credits.
+
+## Install it on your computer
+
+The same account on your own machine: it thinks with your Claude, ChatGPT, Gemini or Cursor
+subscription, reads your local files and browses for you, and what you publish keeps running in
+the cloud behind the same links. On macOS or Linux, in a terminal:
 
 ```bash
 curl -fsSL https://engenty.ai/install.sh | bash
 ```
 
-It needs nothing but `curl` and asks for no password. It brings its own Node.js (a Node you
-already have is left alone), installs engenty wizards into `~/.engenty/wizards` and then walks
-you through the rest:
+It needs nothing but `curl` and `tar` and asks for no password. It brings its own Node.js (a
+Node you already have is left alone), installs engenty wizards into `~/.engenty/wizards` and
+then walks you through the rest:
 
+- **Your engenty account.** A code and the browser for the sign-in; your team's space comes
+  down to this computer. "Later" skips it, `wizards account sign-in` does it any time.
+  `--local` leaves the account out: nothing leaves the computer, links answer on it only
+  ([local only](https://engenty.ai/docs/user/local-only)).
 - **Something to think with.** It looks for Codex, Claude Code, Gemini CLI and Cursor Agent and
   offers to install one if there is none — first the one whose app (Claude, ChatGPT, Cursor) is
   on your Mac, as its subscription is most likely yours already. The first page of the studio
-  installs them too. Or use an API key or [Ollama](https://ollama.com).
+  installs them too. Or use your account's credits, an API key or [Ollama](https://ollama.com).
 - **Google Chrome and ffmpeg** (optional): Chrome for PDF and PNG exports and for steps that use
   a browser, ffmpeg for MP4 videos of animated widgets.
 - **Start at login** (optional): engenty wizards starts in the background when you log in (a
   LaunchAgent on a Mac, a systemd user service on Linux). Links and AI clients then always
   reach it. `wizards autostart on` or `off` switches it later.
 
-Then it starts and the studio opens in your browser. Later, start it with:
+It starts nothing. Afterwards:
 
 ```bash
-wizards
+wizards start
 ```
 
-It runs while that terminal is open; Ctrl-C stops it. `wizards status` says what is
-installed and what runs, `wizards setup` runs the guided setup again, and
-`wizards --help` lists the rest.
+starts it and opens the studio; it runs while that terminal is open, Ctrl-C stops it.
+`wizards` opens a menu with all of it, `wizards status` says what is installed and what runs,
+`wizards setup` runs the guided setup again, and `wizards --help` lists the rest.
 
 **Install it as an app.** In Chrome or Edge the studio installs as an app: its own window, its
 own icon in the Dock or taskbar. The studio offers it in a banner at the top; or click the install
@@ -99,9 +112,10 @@ machine; a checkout brings its own sandbox, the installed version has none yet.
 
 ## First start
 
-The setup asks what engenty should think with. Pick an AI client that is installed on your
-computer — engenty uses your existing subscription and signs it in for you in a terminal right
-on the page — or enter your own keys. It stays until a test call works, then the studio opens.
+The setup shows your account at the top and asks what engenty should think with. Pick an AI
+client that is installed on your computer — engenty uses your existing subscription and signs
+it in for you in a terminal right on the page — your account's credits, or enter your own keys.
+It stays until a test call works, then the studio opens.
 
 Change it later under Settings.
 

package/apps/runtime/dist/agents/studio-assistant.js

@@ -1,11 +1,12 @@
 import { anthropic } from "@ai-sdk/anthropic";
-import { cleanAssetSections, cleanLogoSections, FACT_TYPES, factKey, gradientCss, PROJECT_FILE_KINDS, PROJECT_LIMITS, parseGradient, RULE_MARKS, textStyleLine, } from "@engenty-wizards/shared/projects";
+import { cleanAssetSections, cleanLogoSections, FACT_TYPES, FONT_USES, factKey, gradientCss, PROJECT_FILE_KINDS, PROJECT_LIMITS, parseGradient, RULE_MARKS, textStyleLine, } from "@engenty-wizards/shared/projects";
 import { Agent } from "@mastra/core/agent";
 import { createTool } from "@mastra/core/tools";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { knowsTools } from "../assistant/knows.js";
 import { PRIMER } from "../assistant/primer.js";
+import { currentFeatures } from "../features.js";
 import { attachTools, contextWindowOf, costOf, gatewayTools, textModel, usageOf, } from "../models.js";
 import { ServiceError } from "../services/errors.js";
 import { knowledgeCounts } from "../services/knowledge.js";
@@ -48,7 +49,7 @@ THE SPACE
 - Colours: two to six, the main one first, each with a name that says what it is for ("Primär", "Hintergrund", "Text"). Take them from the stylesheet's variables or its most used colours, never from photos. set_colors replaces the list: pass all colours that should remain. Colours in no section are the standard ones; the first of them is the accent. Colour sections are optional like logo sections: only for a further palette a brand guide or the person names for its own use ("Illustration – drawings and charts"), never for the standard colours. A brand's gradients (set_gradients, as CSS) only where a brand guide or the site's stylesheet has them; patterns and background fills are pictures the person uploads.
 - Logos: save the best candidate (an SVG or a large PNG rather than a favicon); a second one only if it truly differs (for dark ground, a signet). A few images that show the business (header, team, products) may be saved as assets — a handful, never everything.
 - Logo sections and rules are optional, and most spaces need neither. Logos in no section are the standard ones; the first of them is the main logo. Add a section (set_logo_sections) only for further variants that a brand guide, a brand or press page or the person says are used elsewhere: the title names the variant ("Logomark", "Wordmark"), the description says when to use it ("Small spaces: app icons, favicons"). The standard logos never go into a section; one logo, or a light and a dark one whose descriptions already tell them apart, get no sections. Rules (set_rules, for the logos, the colours or the type) are short rows, one rule each, with a sign: do ("Keep clear space of the mark's height on all sides"), dont ("Place it on photos"), important, question (something to check with the person), number (steps in order), or none for a plain note (minimum size, file formats). Only what such a source or the person states; never invent rules and never write general advice a brand guide did not say.
-- Typography: the brand's fonts (set_typography), each with what it is for ("Headings", "Body text") and the weights it uses — from the website's stylesheet (read_website lists its fonts) or a brand guide; system and generic faces are no brand fonts. A type scale (text styles: name, size, weight, line height, letter spacing) only when a brand guide gives one.
+- Typography: the brand's fonts (set_typography), each with what it is for ("Headings", "Body text") and the weights it uses — from the website's stylesheet (read_website lists its fonts) or a brand guide; system and generic faces are no brand fonts. A font's licence and what it may be used for (web, documents, print, images, video) only where a brand guide, the font's own page or the person says so; the wizards keep to it. A type scale (text styles: name, size, weight, line height, letter spacing) only when a brand guide gives one.
 - Asset sections are optional too: tabs of one kind each ("Icons", "Background images"), made with set_asset_sections only when the space holds enough assets of clearly different kinds or the person asks; a handful of pictures stay in the general tab.
 - Files the person attached are stored already; the message names them. look_at_file shows you a picture or a document's text. Give a file a description with describe_file when it has none or the person says what it is. Take facts from a document when asked.
 - Wissen (German „Wissen“) is what the wizards' steps look things up in: pages, tables and files, kept apart by typed Kategorien. Documents the person attaches are read into Wissen by themselves: say so; do not copy their text into facts unless asked. A website, a sitemap or a folder whose entries should go into Wissen is a source: where a tool proposes sources, use it (the person takes the proposal on its card); where there is none, say that sources need the Sources plugin.
@@ -125,9 +126,8 @@ async function projectState(userId, projectId) {
         // Optional parts are only there when the space has them.
         ...(p.brand.colorSections?.length
             ? {
-                colorSections: p.brand.colorSections.map(({ title, description, kind }) => ({
+                colorSections: p.brand.colorSections.map(({ title, kind }) => ({
                     title,
-                    description,
                     kind: kind ?? "colors",
                 })),
             }
@@ -136,6 +136,7 @@ async function projectState(userId, projectId) {
             ? {
                 gradients: p.brand.gradients.map((g) => ({
                     name: g.name,
+                    ...(g.description ? { description: g.description } : {}),
                     section: p.brand.colorSections?.find((s) => s.id === g.section)?.title,
                     css: gradientCss(g),
                 })),
@@ -145,6 +146,7 @@ async function projectState(userId, projectId) {
             ? {
                 patterns: p.brand.patterns.map((x) => ({
                     name: x.name,
+                    ...(x.description ? { description: x.description } : {}),
                     section: p.brand.colorSections?.find((s) => s.id === x.section)?.title,
                     tile: Boolean(x.tile),
                 })),
@@ -165,7 +167,15 @@ async function projectState(userId, projectId) {
             }
             : {}),
         ...(p.brand.fonts?.length
-            ? { fonts: p.brand.fonts.map(({ family, role, weights }) => ({ family, role, weights })) }
+            ? {
+                fonts: p.brand.fonts.map(({ family, role, weights, license, uses }) => ({
+                    family,
+                    role,
+                    weights,
+                    ...(license ? { license } : {}),
+                    ...(uses?.length ? { uses } : {}),
+                })),
+            }
             : {}),
         ...(p.brand.textStyles?.length
             ? {
@@ -188,8 +198,7 @@ async function projectState(userId, projectId) {
         })),
     };
 }
-/** The space's own tools: what fills it in. */
-function spaceTools(input, project, wrote) {
+function spaceTools(input, project, wrote, on) {
     const { signal } = input;
     const userId = input.user.id;
     const projectId = project.id;
@@ -292,7 +301,7 @@ function spaceTools(input, project, wrote) {
         }),
         set_colors: createTool({
             id: "set_colors",
-            description: "Set the brand's colours — the whole list, the main colour first. Values as #rrggbb. Optional: `sections` for a further palette of its own use (title, when to use it), and on a colour the `section` title it belongs to; colours without one are the standard ones. Without `sections` the space keeps its sections.",
+            description: "Set the brand's colours — the whole list, the main colour first. Values as #rrggbb. Optional: `sections` for a further palette of its own use (its title), and on a colour the `section` title it belongs to; colours without one are the standard ones. Without `sections` the space keeps its sections.",
             inputSchema: z.object({
                 colors: z
                     .array(z.object({
@@ -302,12 +311,15 @@ function spaceTools(input, project, wrote) {
                 }))
                     .max(PROJECT_LIMITS.colors),
                 sections: z
-                    .array(z.object({ title: z.string().min(1).max(80), description: z.string().max(400) }))
+                    .array(z.object({ title: z.string().min(1).max(80) }))
                     .max(PROJECT_LIMITS.logoSections)
                     .optional(),
             }),
             execute: ({ colors, sections }) => attempt(() => inTurn(async () => {
                 doing("set_colors");
+                if (!on.brandSections && (sections || colors.some((c) => c.section))) {
+                    throw new Error("Colour sections are not available in this studio: pass the colours without them.");
+                }
                 const p = await ownedProject(userId, projectId);
                 const groups = sections
                     ? sections.map((s) => ({
@@ -392,13 +404,22 @@ function spaceTools(input, project, wrote) {
         }),
         set_typography: createTool({
             id: "set_typography",
-            description: "Set the brand's fonts — the whole list, the main one first — each with what it is for and its weights. Optional: `textStyles`, the type scale a brand guide gives (name, font family, size px, weight, line height %, letter spacing %); without it the space keeps its text styles.",
+            description: "Set the brand's fonts — the whole list, the main one first — each with what it is for, its weights and, where a source says so, its licence and what it may be used for. Optional: `textStyles`, the type scale a brand guide gives (name, font family, size px, weight, line height %, letter spacing %); without it the space keeps its text styles.",
             inputSchema: z.object({
                 fonts: z
                     .array(z.object({
                     family: z.string().min(1).max(80),
                     role: z.string().max(200).describe("What it is for, in the person's language"),
                     weights: z.array(z.number().int().min(100).max(900)).max(9),
+                    license: z
+                        .string()
+                        .max(200)
+                        .optional()
+                        .describe("The licence, only where a source names it: 'SIL Open Font License'"),
+                    uses: z
+                        .array(z.enum(FONT_USES))
+                        .optional()
+                        .describe("All the licence allows it for, only where a source says so"),
                 }))
                     .max(PROJECT_LIMITS.fonts),
                 textStyles: z
@@ -441,15 +462,18 @@ function spaceTools(input, project, wrote) {
         }),
         set_gradients: createTool({
             id: "set_gradients",
-            description: "Optional. Set the brand's gradients, as a brand guide or the site's stylesheet gives them: each with a name and its CSS (linear-, radial- or conic-gradient with hex stops). They go into a gradients section, made when there is none with that title. Replaces the gradients of that section.",
+            description: "Optional. Set the brand's gradients, as a brand guide or the site's stylesheet gives them: each with a name, when to use it where the source says so, and its CSS (linear-, radial- or conic-gradient with hex stops). They go into a gradients section, made when there is none with that title. Replaces the gradients of that section.",
             inputSchema: z.object({
                 section: z.string().min(1).max(80).describe("The gradients section's title"),
-                description: z.string().max(400).optional().describe("When to use them"),
                 gradients: z
-                    .array(z.object({ name: z.string().min(1).max(80), css: z.string().max(1000) }))
+                    .array(z.object({
+                    name: z.string().min(1).max(80),
+                    description: z.string().max(400).optional().describe("When to use it"),
+                    css: z.string().max(1000),
+                }))
                     .max(PROJECT_LIMITS.gradients),
             }),
-            execute: ({ section, description, gradients }) => attempt(() => inTurn(async () => {
+            execute: ({ section, gradients }) => attempt(() => inTurn(async () => {
                 doing("set_gradients");
                 const p = await ownedProject(userId, projectId);
                 const sections = p.brand.colorSections ?? [];
@@ -463,16 +487,14 @@ function spaceTools(input, project, wrote) {
                 await updateProject(userId, projectId, {
                     brand: {
                         colorSections: found
-                            ? sections.map((s) => (s.id === id && description ? { ...s, description } : s))
-                            : [
-                                ...sections,
-                                { id, title: section, description: description ?? "", kind: "gradients" },
-                            ],
+                            ? sections
+                            : [...sections, { id, title: section, kind: "gradients" }],
                         gradients: [
                             ...(p.brand.gradients ?? []).filter((g) => g.section !== id),
                             ...parsed.map(({ g, read }) => ({
                                 id: nanoid(10),
                                 name: g.name,
+                                ...(g.description ? { description: g.description } : {}),
                                 section: id,
                                 ...read,
                             })),
@@ -582,6 +604,16 @@ function spaceTools(input, project, wrote) {
             },
         }),
     };
+    if (!on.brandSections) {
+        delete tools.set_logo_sections;
+        delete tools.set_gradients;
+    }
+    if (!on.brandRules) {
+        delete tools.set_rules;
+    }
+    if (!on.typography) {
+        delete tools.set_typography;
+    }
     return tools;
 }
 /** A browser tool as the model calls it: sent to the page, its answer awaited. */
@@ -673,6 +705,12 @@ export async function runStudioAssistant(input) {
     const cards = [];
     const { project } = input;
     const space = project && input.writable ? project : null;
+    const switches = await currentFeatures();
+    const brandOn = {
+        brandSections: switches.brandSections === true,
+        brandRules: switches.brandRules === true,
+        typography: switches.typography === true,
+    };
     const tools = {
         ...knowsTools({
             user: input.user,
@@ -687,7 +725,7 @@ export async function runStudioAssistant(input) {
                 input.onCard?.(card);
             },
         }),
-        ...(space ? spaceTools(input, space, wrote) : {}),
+        ...(space ? spaceTools(input, space, wrote, brandOn) : {}),
     };
     // What the tenant's plugins let the assistant do besides: a source of knowledge, say.
     if (space) {
@@ -763,6 +801,15 @@ export async function runStudioAssistant(input) {
         part === "knowledge"
             ? "The person talks to you from Wissen: they want the wizards to know something."
             : "",
+        space && !(brandOn.brandSections && brandOn.brandRules && brandOn.typography)
+            ? `Not in this studio (no tools for it; never offer it): ${[
+                brandOn.brandSections ? "" : "sections of logos and colours, gradients and patterns",
+                brandOn.brandRules ? "" : "rules for logos, colours and type",
+                brandOn.typography ? "" : "typography (fonts, type scale)",
+            ]
+                .filter(Boolean)
+                .join("; ")}.`
+            : "",
         input.message,
     ]
         .filter(Boolean)

package/apps/runtime/dist/auth/account.js

@@ -9,9 +9,11 @@ import { deleteSetting, readSetting, writeSetting } from "../settings.js";
  * browser at the Manage-App, the code comes back to this server on the loopback interface. The
  * account is optional; it unlocks credits through the gateway and publishing to the cloud.
  */
-const CLIENT = { id: "wizards-desktop" };
+export const CLIENT = { id: "wizards-desktop" };
 const REFRESH = "account.refresh";
-const SCOPE = "openid profile email offline_access wizards:read wizards:write wizards:publish";
+export const SCOPE = "openid profile email offline_access wizards:read wizards:write wizards:publish";
+/** The team of the linked account as the Manage-App last named it, for lines that must not wait on it. */
+const TEAM = "account.team";
 /** Loopback redirect on the port this server listens on (RFC 8252). */
 function redirectUri() {
     return `http://127.0.0.1:${env.port}/api/auth/callback`;
@@ -48,7 +50,11 @@ export async function startLink(options = {}) {
     return signUp.toString();
 }
 let cached = null;
-async function keep(tokens) {
+/**
+ * Keeps what the token endpoint handed out: the refresh token in the vault, the account in the
+ * settings. The browser flow (finishLink) and the device flow (device.ts) end here alike.
+ */
+export async function keep(tokens) {
     const claims = unverifiedClaims(tokens.access_token);
     if (!claims) {
         throw new Error("The account's token names no tenant.");
@@ -128,6 +134,25 @@ export async function unlink() {
     cached = null;
     await vaultDelete(REFRESH);
     await deleteSetting("account");
+    await deleteSetting(TEAM);
+}
+/** The team as the Manage-App last named it: `wizards status` and the menu show it without a round trip. */
+export function knownTeam() {
+    return readSetting(TEAM);
+}
+let rememberedTeam = null;
+async function rememberTeam(tenant) {
+    const same = `${tenant.id}\n${tenant.name}\n${tenant.balanceCredits}`;
+    if (same === rememberedTeam) {
+        return;
+    }
+    rememberedTeam = same;
+    await writeSetting(TEAM, {
+        tenantId: tenant.id,
+        name: tenant.name,
+        balanceCredits: tenant.balanceCredits,
+        at: new Date().toISOString(),
+    });
 }
 /** Balance and tenants of the linked account, straight from the Manage-App. */
 export async function accountOverview() {
@@ -139,5 +164,12 @@ export async function accountOverview() {
         headers: { authorization: `Bearer ${token}` },
         signal: AbortSignal.timeout(10_000),
     }).catch(() => null);
-    return res?.ok ? (await res.json()) : null;
+    if (!res?.ok) {
+        return null;
+    }
+    const overview = (await res.json());
+    if (overview?.tenant) {
+        await rememberTeam(overview.tenant).catch(() => undefined);
+    }
+    return overview;
 }

package/apps/runtime/dist/auth/device.js

@@ -0,0 +1,101 @@
+import { env } from "../env.js";
+import { discovery, ManageError, tokenRequest } from "../manage.js";
+import { CLIENT, keep, SCOPE } from "./account.js";
+/**
+ * Signing in from a terminal (RFC 8628): the Manage-App hands out a code, the person types it
+ * on any browser at the account's /device page and allows it, and this process asks the token
+ * endpoint until they did. For `wizards setup` and `wizards account sign-in`; the studio keeps
+ * the browser flow of account.ts. Both end in the same keep(): the refresh token in the vault,
+ * the account in the settings, so the runtime picks it up wherever it runs.
+ *
+ *   POST <account>/api/auth/device/code      client_id, scope, resource → the codes
+ *   POST <token endpoint of the discovery>   grant_type device_code, every `interval` seconds,
+ *                                            until tokens come, or the code expired or was refused
+ */
+const GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+/** Why a sign-in ended without an account; the message is for the person. */
+export class DeviceSignInError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+    }
+}
+/** Asks the Manage-App for a code to sign this install in with. */
+export async function requestDeviceCode() {
+    const base = env.local.accountUrl;
+    // The discovery names the endpoint when the Manage-App advertises it.
+    const d = (await discovery(base).catch(() => null));
+    const res = await fetch(d?.device_authorization_endpoint ?? `${base}/api/auth/device/code`, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            client_id: CLIENT.id,
+            scope: SCOPE,
+            resource: env.local.cloudUrl,
+        }),
+        signal: AbortSignal.timeout(15_000),
+    }).catch(() => null);
+    if (!res) {
+        throw new DeviceSignInError("unreachable", `${base} is not reachable right now.`);
+    }
+    const data = (await res.json().catch(() => ({})));
+    if (!(res.ok && data.device_code && data.user_code && data.verification_uri)) {
+        throw new DeviceSignInError("refused", data.error_description ||
+            (data.error
+                ? `The account refused the sign-in (${data.error}).`
+                : `The account did not hand out a code (${res.status}).`));
+    }
+    return {
+        deviceCode: data.device_code,
+        userCode: data.user_code,
+        verificationUri: data.verification_uri,
+        verificationUriComplete: data.verification_uri_complete ?? null,
+        expiresAt: Date.now() + (data.expires_in ?? 1800) * 1000,
+        interval: Math.max(1, data.interval ?? 5),
+    };
+}
+const pause = (ms) => new Promise((done) => setTimeout(done, ms));
+/**
+ * Asks the token endpoint until the person allowed the code in the browser, and keeps the
+ * tokens as the browser flow does. `authorization_pending` asks again after `interval`;
+ * `slow_down` asks five seconds later each time (RFC 8628 §3.5); a network error is tried
+ * again a few times. `expired_token` and `access_denied` end it.
+ */
+export async function waitForDeviceSignIn(code, options = {}) {
+    const wait = options.wait ?? pause;
+    let interval = code.interval;
+    let failures = 0;
+    for (;;) {
+        await wait(interval * 1000);
+        if (Date.now() >= code.expiresAt) {
+            throw new DeviceSignInError("expired", "The code has expired. Start the sign-in again.");
+        }
+        try {
+            const tokens = await tokenRequest({ grant_type: GRANT, device_code: code.deviceCode, resource: env.local.cloudUrl }, CLIENT, env.local.accountUrl);
+            return await keep(tokens);
+        }
+        catch (err) {
+            if (!(err instanceof ManageError)) {
+                if (++failures >= 5) {
+                    throw new DeviceSignInError("unreachable", `${env.local.accountUrl} stopped answering. Start the sign-in again.`);
+                }
+                continue;
+            }
+            failures = 0;
+            switch (err.code) {
+                case "authorization_pending":
+                    continue;
+                case "slow_down":
+                    interval += 5;
+                    continue;
+                case "expired_token":
+                    throw new DeviceSignInError("expired", "The code has expired. Start the sign-in again.");
+                case "access_denied":
+                    throw new DeviceSignInError("denied", "The sign-in was refused in the browser.");
+                default:
+                    throw new DeviceSignInError("refused", `The account refused the sign-in (${err.code}).`);
+            }
+        }
+    }
+}

package/apps/runtime/dist/auth/index.js

@@ -273,7 +273,7 @@ export const authRoutes = new Hono()
     if (!managed) {
         // The linked account of a runtime that runs alone: the system browser lands here.
         if (!code) {
-            return c.html(closePage("Anmeldung abgebrochen. Du kannst dieses Fenster schließen."), 400);
+            return c.html(closePage("Sign-in cancelled. You can close this window."), 400);
         }
         try {
             await finishLink(code, rawState);
@@ -281,11 +281,11 @@ export const authRoutes = new Hono()
             void firstSync();
             // The Pro modules the account's plan includes.
             void refreshPro();
-            return c.html(closePage("Angemeldet. Du kannst dieses Fenster schließen."));
+            return c.html(closePage("Signed in. You can close this window."));
         }
         catch (err) {
             console.error("[account]", err);
-            return c.html(closePage("Anmeldung hat nicht geklappt. Bitte noch einmal versuchen."), 400);
+            return c.html(closePage("The sign-in did not work. Please try again."), 400);
         }
     }
     const state = unseal(getCookie(c, STATE_COOKIE) ?? "");
@@ -322,7 +322,7 @@ export const authRoutes = new Hono()
                 exp: Date.now() + 2 * 60_000,
             });
             const link = `engenty-wizards://signin?code=${encodeURIComponent(code)}`;
-            return c.html(`${closePage("Angemeldet. Kehre jetzt zu engenty wizards zurück.")}
+            return c.html(`${closePage("Signed in. Go back to engenty wizards now.")}
 <script>location.href = ${JSON.stringify(link)};</script>`);
         }
         setSessionCookie(c, id);