@invitedlabs/cli 0.0.0-stage → 0.1.0

package/dist/connect.js

@@ -0,0 +1,192 @@
+import { randomBytes } from 'node:crypto';
+import { mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { CliError, errorCode } from './errors.js';
+import { plural } from './format.js';
+import { mcpUrl } from './oauth.js';
+import { setServerTable, ShapeError, tomlArray, tomlString } from './toml.js';
+/**
+ * `invited connect <host>`: writes Invited's MCP server (https://invited.you/mcp)
+ * into a host's own configuration file under the name `invited`, merging with
+ * what is there and never touching another server's entry. Each host signs in
+ * to Invited itself (OAuth with PKCE, as its documentation describes), so the
+ * entry holds no token. `--bridge` writes the mcp-remote bridge instead
+ * (`npx -y mcp-remote@<pinned> <url>`), for a host version without remote OAuth.
+ *
+ * Formats, checked against each host's documentation on 11 October 2026
+ * (docs/mcp-connector-2026-10-11.md, "3e: CLI"):
+ *   claude-code  ~/.claude.json, mcpServers.invited = { type: "http", url } (user scope)
+ *   cursor       ~/.cursor/mcp.json, mcpServers.invited = { url }
+ *   codex        ~/.codex/config.toml ($CODEX_HOME), [mcp_servers.invited] url = "…"
+ *   gemini       ~/.gemini/settings.json, mcpServers.invited = { httpUrl }
+ */
+export const SERVER_NAME = 'invited';
+export const HOSTS = ['claude-code', 'cursor', 'codex', 'gemini'];
+const HOST = {
+    'claude-code': {
+        label: 'Claude Code',
+        format: 'json',
+        file: home => join(home, '.claude.json'),
+        scope: 'user scope: every project',
+        native: url => ({ type: 'http', url }),
+        bridged: bridge => ({ type: 'stdio', ...bridge }),
+        signIn: 'Claude Code signs in to Invited itself: run `claude mcp login invited` (or /mcp inside Claude Code) and approve in your browser.',
+        source: 'https://code.claude.com/docs/en/mcp',
+    },
+    cursor: {
+        label: 'Cursor',
+        format: 'json',
+        file: home => join(home, '.cursor', 'mcp.json'),
+        scope: 'global: every project',
+        native: url => ({ url }),
+        bridged: bridge => ({ type: 'stdio', ...bridge }),
+        signIn: 'Cursor signs in to Invited itself: in Cursor, open Customize > MCP, sign in to invited and approve in your browser.',
+        source: 'https://cursor.com/docs/mcp',
+    },
+    codex: {
+        label: 'Codex CLI',
+        format: 'toml',
+        file: (home, env) => join(env.CODEX_HOME?.trim() || join(home, '.codex'), 'config.toml'),
+        scope: 'user configuration, shared by the Codex CLI, IDE extension and app',
+        native: url => ({ url }),
+        bridged: bridge => ({ ...bridge }),
+        signIn: 'Codex signs in to Invited itself: run `codex mcp login invited` and approve in your browser.',
+        source: 'https://developers.openai.com/codex/mcp',
+    },
+    gemini: {
+        label: 'Gemini CLI',
+        format: 'json',
+        file: home => join(home, '.gemini', 'settings.json'),
+        scope: 'user settings: every project',
+        native: url => ({ httpUrl: url }),
+        bridged: bridge => ({ ...bridge }),
+        signIn: 'Gemini CLI signs in to Invited itself: start gemini and approve in your browser when it connects (/mcp auth invited signs in again).',
+        source: 'https://geminicli.com/docs/tools/mcp-server/',
+    },
+};
+/** Keys that say how a host reaches a server; an entry of one transport loses the other's. */
+const TRANSPORT_KEYS = ['type', 'url', 'httpUrl', 'command', 'args', 'env', 'cwd'];
+/** The bridge, pinned to the version reviewed for 5b (npm, September 2026).
+ * Unpinned, `npx -y` would run whatever is published next inside the host;
+ * versions below 0.1.16 had a remote code execution flaw (security review
+ * L10). Raise it only after reviewing the new version. */
+export const MCP_REMOTE = 'mcp-remote@0.14.3';
+export function bridgeFor(url, platform) {
+    const args = ['-y', MCP_REMOTE, url, ...(url.startsWith('http://') ? ['--allow-http'] : [])];
+    // npx is a .cmd script on Windows, which a host can only start through cmd.
+    return platform === 'win32' ? { command: 'cmd', args: ['/c', 'npx', ...args] } : { command: 'npx', args };
+}
+/** The entry merged into a JSON configuration: the existing entry's own
+ * settings (a timeout, trust, tool lists) are kept, its transport replaced. */
+export function mergeJson(source, entry) {
+    const bom = source?.startsWith('\uFEFF') ? '\uFEFF' : '';
+    const text = bom ? source.slice(1) : (source ?? '');
+    let root = {};
+    if (text.trim()) {
+        try {
+            root = JSON.parse(text);
+        }
+        catch {
+            throw new ShapeError('it is not plain JSON (comments or a syntax error)');
+        }
+    }
+    if (typeof root !== 'object' || root === null || Array.isArray(root))
+        throw new ShapeError('it is not a JSON object');
+    const config = root;
+    const servers = config.mcpServers ?? {};
+    if (typeof servers !== 'object' || servers === null || Array.isArray(servers))
+        throw new ShapeError('its mcpServers is not an object');
+    const existing = servers[SERVER_NAME];
+    const kept = typeof existing === 'object' && existing !== null && !Array.isArray(existing)
+        ? Object.fromEntries(Object.entries(existing).filter(([key]) => !TRANSPORT_KEYS.includes(key)))
+        : {};
+    const next = { ...entry, ...kept };
+    const others = Object.keys(servers).filter(name => name !== SERVER_NAME);
+    if (JSON.stringify(existing) === JSON.stringify(next))
+        return { text: source ?? '', change: 'unchanged', others };
+    servers[SERVER_NAME] = next;
+    config.mcpServers = servers;
+    const indent = /^([ \t]+)"/m.exec(text)?.[1] ?? '  ';
+    const eol = text.includes('\r\n') ? '\r\n' : '\n';
+    const body = JSON.stringify(config, null, indent).replace(/\n/g, eol);
+    return {
+        text: bom + body + (text && !/\r?\n$/.test(text) ? '' : eol),
+        change: existing === undefined ? 'added' : 'updated',
+        others,
+    };
+}
+async function readOptional(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return null;
+        throw new CliError(`Could not read ${path} (${errorCode(error) ?? 'unknown error'}).`);
+    }
+}
+/** Replace the file atomically, keeping its permissions. */
+async function writeAtomically(path, text) {
+    const mode = (await stat(path).catch(() => null))?.mode;
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = join(dirname(path), `.${SERVER_NAME}-${process.pid}-${randomBytes(6).toString('hex')}.tmp`);
+    try {
+        await writeFile(temporary, text, { flag: 'wx', mode: mode === undefined ? 0o644 : mode & 0o777 });
+        await rename(temporary, path);
+    }
+    catch (error) {
+        await rm(temporary, { force: true });
+        throw new CliError(`Could not write ${path} (${errorCode(error) ?? 'unknown error'}).`);
+    }
+}
+export async function connect(options) {
+    const name = options.host;
+    if (!name || !HOSTS.includes(name))
+        throw new CliError(`${name ? `${name} is not a host this CLI configures.` : 'Name the host to configure.'} Use one of: ${HOSTS.join(', ')}. For example: invited connect claude-code`);
+    const host = HOST[name];
+    const url = mcpUrl(options.origin);
+    const file = resolve(options.config ?? host.file(options.home, options.env));
+    const bridge = bridgeFor(url, options.platform);
+    const entry = options.bridge ? host.bridged(bridge) : host.native(url);
+    const source = await readOptional(file);
+    const values = Object.entries(entry).map(([key, value]) => [
+        key,
+        Array.isArray(value) ? tomlArray(value) : tomlString(String(value)),
+    ]);
+    const shown = host.format === 'json'
+        ? [`mcpServers.${SERVER_NAME} = ${JSON.stringify(entry)}`]
+        : [`[mcp_servers.${SERVER_NAME}]`, ...values.map(([key, value]) => `${key} = ${value}`)];
+    let result;
+    try {
+        result =
+            host.format === 'json'
+                ? mergeJson(source, entry)
+                : setServerTable(source, SERVER_NAME, values, TRANSPORT_KEYS.filter(key => !(key in entry)));
+    }
+    catch (error) {
+        if (!(error instanceof ShapeError))
+            throw error;
+        const manual = host.format === 'json' ? JSON.stringify({ mcpServers: { [SERVER_NAME]: entry } }, null, 2) : shown.join('\n');
+        throw new CliError(`${file} was left as it is: ${error.message}. Add this to it by hand:\n${manual}`);
+    }
+    const lines = [];
+    if (result.change === 'unchanged')
+        lines.push(`${host.label} already has Invited (${host.scope}); nothing changed.`);
+    else if (options.dryRun)
+        lines.push(`Dry run: nothing was written. This would ${result.change === 'added' ? 'add' : 'update'} Invited in ${host.label} (${host.scope}):`);
+    else
+        lines.push(`${result.change === 'added' ? 'Added' : 'Updated'} Invited in ${host.label} (${host.scope}):`);
+    lines.push(`  file   ${file}`, `  entry  ${shown.join('\n         ')}`, `  format ${host.source}`);
+    lines.push(result.others.length
+        ? `The ${plural(result.others.length, 'other MCP server')} in that file ${result.others.length === 1 ? 'is' : 'are'} left as ${result.others.length === 1 ? 'it is' : 'they are'} (${result.others.join(', ')}).`
+        : 'No other MCP server is configured in that file.');
+    if (options.bridge)
+        lines.push(`Configured through the mcp-remote bridge (${[bridge.command, ...bridge.args].join(' ')}): ${host.label} starts it, and mcp-remote opens your browser to approve Invited the first time.`);
+    else
+        lines.push(host.signIn);
+    if (name === 'claude-code' && options.env.CLAUDE_CONFIG_DIR && !options.config)
+        lines.push('CLAUDE_CONFIG_DIR is set: if Claude Code keeps its configuration there, run this again with --config <that folder>/.claude.json.');
+    if (!options.dryRun && result.change !== 'unchanged')
+        await writeAtomically(file, result.text);
+    options.out(lines.join('\n') + '\n');
+}

package/dist/credentials.js

@@ -0,0 +1,150 @@
+import { randomBytes } from 'node:crypto';
+import { chmod, mkdir, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { CliError, errorCode } from './errors.js';
+export const configDir = (env, home) => env.INVITED_CONFIG_DIR?.trim() || join(home, '.invited');
+const DAY_MS = 86_400_000;
+/** How long a lock may be held before another command takes it: three times
+ * the longest request a renewal makes (cli/src/http.ts, 30 seconds), so a
+ * slow renewal is never abandoned mid-way (security review L10). A lock whose
+ * process has ended is taken at once. */
+export const LOCK_LIFETIME_MS = 90_000;
+/** Is this process still running? (Signal 0 tests without signalling; EPERM
+ * means it runs as someone else.) */
+function running(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return errorCode(error) === 'EPERM';
+    }
+}
+/** Invited's refresh token lifetimes (migration 136): 30 days idle, 90 days in all. */
+export function refreshExpiry(connection) {
+    const idle = Date.parse(connection.lastUsedAt) + 30 * DAY_MS, latest = Date.parse(connection.connectedAt) + 90 * DAY_MS;
+    return { expiresAt: Math.min(idle, latest), latest };
+}
+const text = (value) => typeof value === 'string' && value.length > 0;
+const optionalText = (value) => value === null || text(value);
+function isConnection(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const item = value;
+    return (['origin', 'clientId', 'resource', 'tokenEndpoint', 'revocationEndpoint', 'identityId', 'refreshToken'].every(key => text(item[key])) &&
+        ['connectedAt', 'lastUsedAt'].every(key => text(item[key]) && !Number.isNaN(Date.parse(item[key]))) &&
+        Array.isArray(item.scopes) &&
+        item.scopes.every(text) &&
+        optionalText(item.pageUrl) &&
+        optionalText(item.pageReadAt));
+}
+export function credentialStore(dir) {
+    const path = join(dir, 'credentials.json');
+    const lockPath = join(dir, 'credentials.lock');
+    async function read() {
+        let source;
+        try {
+            source = await readFile(path, 'utf8');
+        }
+        catch (error) {
+            if (errorCode(error) === 'ENOENT')
+                return { version: 1, connections: {} };
+            throw new CliError(`Could not read ${path} (${errorCode(error) ?? 'unknown error'}).`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(source);
+        }
+        catch {
+            throw new CliError(`${path} is not valid JSON. Delete it and run \`invited login\` again.`);
+        }
+        const file = parsed;
+        if (file?.version !== 1 ||
+            typeof file.connections !== 'object' ||
+            file.connections === null ||
+            !Object.entries(file.connections).every(([origin, item]) => isConnection(item) && item.origin === origin))
+            throw new CliError(`${path} is not in the format this CLI writes. Delete it and run \`invited login\` again.`);
+        return file;
+    }
+    /** Is the file readable by other users? (POSIX only; Windows keeps it to the user's profile.) */
+    async function tooOpen() {
+        if (process.platform === 'win32')
+            return false;
+        const info = await stat(path).catch(() => null);
+        return !!info && (info.mode & 0o077) !== 0;
+    }
+    /** Replace the file atomically (a temporary file renamed over it), or
+     * delete it when no connection is left. */
+    async function write(file) {
+        if (!Object.keys(file.connections).length) {
+            await rm(path, { force: true });
+            return;
+        }
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+        const temporary = join(dir, `.credentials-${process.pid}-${randomBytes(6).toString('hex')}.tmp`);
+        try {
+            await writeFile(temporary, JSON.stringify(file, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+            await rename(temporary, path);
+            await chmod(path, 0o600);
+        }
+        catch (error) {
+            await rm(temporary, { force: true });
+            throw new CliError(`Could not save ${path} (${errorCode(error) ?? 'unknown error'}).`);
+        }
+    }
+    /** Is the lock's holder gone? Its process has ended, or it took the lock
+     * more than LOCK_LIFETIME_MS ago. The lock holds `{ pid, at }`; an older
+     * CLI's lock holds the PID alone and is dated by the file. */
+    async function abandoned() {
+        const info = await stat(lockPath).catch(() => null);
+        if (!info)
+            return false;
+        let holder = null;
+        try {
+            holder = JSON.parse(await readFile(lockPath, 'utf8'));
+        }
+        catch {
+            holder = null;
+        }
+        const record = typeof holder === 'object' && holder !== null ? holder : {};
+        const pid = typeof holder === 'number' ? holder : record.pid;
+        const at = typeof record.at === 'number' ? record.at : info.mtimeMs;
+        if (Date.now() - at > LOCK_LIFETIME_MS)
+            return true;
+        return typeof pid === 'number' && Number.isInteger(pid) && pid > 0 && pid !== process.pid && !running(pid);
+    }
+    /** Run `task` holding the credentials lock, so two commands never renew
+     * the same refresh token (Invited would see the second use as theft and
+     * end the connection). A lock is abandoned only when its process has ended
+     * or after LOCK_LIFETIME_MS. */
+    async function locked(task) {
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+        const started = Date.now();
+        for (;;) {
+            try {
+                const handle = await open(lockPath, 'wx', 0o600);
+                await handle.writeFile(JSON.stringify({ pid: process.pid, at: Date.now() }));
+                await handle.close();
+                break;
+            }
+            catch (error) {
+                if (!['EEXIST', 'EPERM', 'EBUSY'].includes(errorCode(error) ?? ''))
+                    throw new CliError(`Could not lock ${lockPath} (${errorCode(error) ?? 'unknown error'}).`);
+                if (await abandoned()) {
+                    await rm(lockPath, { force: true });
+                    continue;
+                }
+                if (Date.now() - started > LOCK_LIFETIME_MS + 5_000)
+                    throw new CliError(`Another invited command is using ${path}. Try again in a moment, or delete ${lockPath} if none is running.`);
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+        }
+        try {
+            return await task();
+        }
+        finally {
+            await rm(lockPath, { force: true });
+        }
+    }
+    return { path, read, write, locked, tooOpen };
+}

package/dist/errors.js

@@ -0,0 +1,9 @@
+/** A failure the CLI explains in plain words: printed on stderr, exit code 1. */
+export class CliError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CliError';
+    }
+}
+/** The error code Node gives a failed file or network operation, if any. */
+export const errorCode = (error) => typeof error === 'object' && error !== null && 'code' in error ? String(error.code) : null;

package/dist/format.js

@@ -0,0 +1,25 @@
+export function style(env) {
+    const forced = !!env.FORCE_COLOR && !['0', 'false'].includes(env.FORCE_COLOR);
+    const colour = forced && !env.NO_COLOR;
+    return { bold: text => (colour ? `\u001b[1m${text}\u001b[22m` : text) };
+}
+/** "11 Oct 2026, 14:02 BST", in the reader's zone (or the one given). */
+export function formatTime(time, timeZone) {
+    return new Intl.DateTimeFormat('en-GB', {
+        day: 'numeric',
+        month: 'short',
+        year: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+        hourCycle: 'h23',
+        timeZoneName: 'short',
+        timeZone,
+    }).format(new Date(time));
+}
+/** "5 minutes", "30 seconds". */
+export function duration(ms) {
+    if (ms >= 60_000 && ms % 60_000 === 0)
+        return plural(ms / 60_000, 'minute');
+    return plural(Math.max(1, Math.ceil(ms / 1000)), 'second');
+}
+export const plural = (count, word) => `${count} ${word}${count === 1 ? '' : 's'}`;

package/dist/http.js

@@ -0,0 +1,39 @@
+import { CliError, errorCode } from './errors.js';
+import { USER_AGENT } from './version.js';
+const TIMEOUT_MS = 30_000;
+/** One HTTP request to Invited. Redirects are refused: a token is only ever
+ * sent to the address it was issued for. A network failure is explained. */
+export async function send(fetch, url, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set('user-agent', USER_AGENT);
+    try {
+        return await fetch(url, { ...init, headers, redirect: 'error', signal: AbortSignal.timeout(TIMEOUT_MS) });
+    }
+    catch (error) {
+        throw new CliError(`Could not reach ${new URL(url).origin} (${networkReason(error)}). Check your connection and try again.`);
+    }
+}
+function networkReason(error) {
+    if (error instanceof Error && (error.name === 'TimeoutError' || error.name === 'AbortError'))
+        return 'no answer';
+    const cause = error instanceof Error ? error.cause : undefined;
+    return errorCode(cause) ?? errorCode(error) ?? (error instanceof Error ? error.message : String(error));
+}
+/** A JSON body as an object, or an empty object when it is not JSON. */
+export async function readJson(response) {
+    const text = await response.text();
+    try {
+        const value = JSON.parse(text);
+        return typeof value === 'object' && value !== null && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Retry-After in whole seconds, when the answer gives one. */
+export function retryAfter(response) {
+    const value = Number(response.headers.get('retry-after'));
+    return Number.isFinite(value) && value > 0 ? Math.ceil(value) : null;
+}

package/dist/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from './main.js';
+process.exitCode = await main(process.argv.slice(2));

package/dist/loopback.js

@@ -0,0 +1,140 @@
+import { randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { duration } from './format.js';
+const escape = (text) => text.replace(/[&<>"']/g, character => `&#${character.charCodeAt(0)};`);
+/** The Invited lockup (public/brand/invited-lockup.svg: the loading-screen
+ * proportions, mark larger than wordmark), drawn in the page's ink. */
+const LOCKUP = '<svg viewBox="0 0 440 160" fill="none" xmlns="http://www.w3.org/2000/svg" aria-label="Invited" role="img">' +
+    '<path d="M60.3125 69.9999H70.5454C72.0037 69.9999 73.2485 69.4843 74.2797 68.4531L107.632 35.1007C108.663 34.0695 109.695 34.0695 110.726 35.1007L121.774 46.1492C122.805 47.1804 122.805 48.2116 121.774 49.2428L92.5639 78.4531C91.5327 79.4843 91.5327 80.5155 92.5639 81.5467L121.774 110.757C122.805 111.788 122.805 112.819 121.774 113.851L110.726 124.899C109.695 125.93 108.663 125.93 107.632 124.899L74.2797 91.5467C73.2485 90.5155 72.0037 89.9999 70.5454 89.9999H60.3125C58.8542 89.9999 58.125 89.2708 58.125 87.8124V72.1874C58.125 70.7291 58.8542 69.9999 60.3125 69.9999Z" fill="currentColor"/>' +
+    '<path d="M49.6875 66.875H35.3125C34.1044 66.875 33.125 67.8544 33.125 69.0625V90.9375C33.125 92.1456 34.1044 93.125 35.3125 93.125H49.6875C50.8956 93.125 51.875 92.1456 51.875 90.9375V69.0625C51.875 67.8544 50.8956 66.875 49.6875 66.875Z" fill="currentColor"/>' +
+    '<path d="M163.28 106H152.4V49.04H163.28V106ZM205.688 106H195.368V80.72C195.368 75.12 193.368 72.32 188.328 72.32C182.888 72.32 179.368 76.24 179.368 82.96V106H169.048V64.72H178.888V71.44C181.128 67.04 184.808 63.92 191.528 63.92C200.968 63.92 205.688 68.72 205.688 78.72V106ZM233.395 106H220.915L205.635 64.72H216.435L227.155 96.96L237.875 64.72H248.675L233.395 106ZM260.896 106H250.576V64.72H260.896V106ZM255.776 58.56C251.936 58.56 249.776 56.24 249.776 53.2C249.776 50.16 251.936 47.84 255.776 47.84C259.616 47.84 261.696 50.16 261.696 53.2C261.696 56.24 259.616 58.56 255.776 58.56ZM281.988 106.4C272.628 106.4 269.508 103.52 269.508 94.4V72.08H263.028V64.72H269.508V52.24H279.828V64.72H288.788V72.08H279.828V94.8C279.828 98 281.188 99.12 284.468 99.12L288.788 99.04V106C287.108 106.16 283.828 106.4 281.988 106.4ZM309.745 106.8C296.305 106.8 288.785 98.4 288.785 85.36C288.785 72.64 295.985 63.92 309.265 63.92C322.625 63.92 329.825 72.72 329.825 84.88C329.825 85.76 329.745 86.56 329.665 87.52H299.105C299.425 95.92 303.425 99.76 309.745 99.76C314.865 99.76 318.225 97.2 319.425 92.96H328.945C327.185 101.44 320.865 106.8 309.745 106.8ZM309.265 70.96C303.585 70.96 299.985 74.24 299.105 80.8H319.505C318.625 74.24 314.945 70.96 309.265 70.96ZM349.936 106.8C338.816 106.8 331.776 98.88 331.776 85.36C331.776 71.84 338.816 63.92 349.936 63.92C356.176 63.92 360.336 66.48 362.656 70.96V49.04H372.976V106H363.136V98.96C360.896 103.76 356.816 106.8 349.936 106.8ZM352.336 98.96C358.496 98.96 362.656 94.8 362.656 85.36C362.656 75.92 358.496 71.76 352.336 71.76C346.256 71.76 342.096 75.92 342.096 85.36C342.096 94.8 346.256 98.96 352.336 98.96Z" fill="currentColor"/>' +
+    '</svg>';
+/** The page the browser shows when it comes back to the CLI: the sign-in
+ * screens' look (dark, the lockup, one cut-corner panel; styles/invited.css
+ * tokens copied here, since this page loads nothing from anywhere). The
+ * stylesheet carries a per-response nonce, so the policy admits nothing else. */
+function page(response, status, title, message, after) {
+    const nonce = randomBytes(16).toString('base64url');
+    const tone = status === 200 ? 'Connected' : 'Not connected';
+    const style = `:root{color-scheme:dark}*{box-sizing:border-box}` +
+        `body{margin:0;min-height:100dvh;display:grid;place-items:center;padding:32px 24px;background:#121212;color:#f5f5f5;` +
+        `font:400 14px/20px 'Creato Display','Helvetica Neue',Arial,sans-serif;-webkit-font-smoothing:antialiased}` +
+        // The design system's cut-corner frame (styles/invited.css, .iv-dialog): a
+        // 1px frame in the line colour, and the surface inside it cut 2 − √2 of a
+        // pixel less, so the diagonal frame is as thick as the straight one.
+        `main{width:100%;max-width:440px;padding:1px;background:#4a4a4a;` +
+        `clip-path:polygon(0 0,calc(100% - 16px) 0,100% 16px,100% 100%,16px 100%,0 calc(100% - 16px))}` +
+        `main>div{padding:40px 36px 36px;background:#1c1c1c;` +
+        `clip-path:polygon(0 0,calc(100% - 15.414px) 0,100% 15.414px,100% 100%,15.414px 100%,0 calc(100% - 15.414px))}` +
+        `.lockup{display:block;width:clamp(91px,30vw,138px);height:auto;margin:0 0 28px -10px;color:#f5f5f5}` +
+        `.eyebrow{margin:0 0 12px;font:400 11px/16px 'B612 Mono',ui-monospace,Menlo,Consolas,monospace;letter-spacing:.08em;text-transform:uppercase;color:#bdbdbd}` +
+        `.eyebrow b{font-weight:400;color:${status === 200 ? '#8fd3a4' : '#f0b36c'}}` +
+        `h1{margin:0 0 10px;font:500 24px/30px 'Creato Display','Helvetica Neue',Arial,sans-serif;letter-spacing:-.3px;text-wrap:balance}` +
+        `p{margin:0;color:#bdbdbd}` +
+        `@media (max-width:480px){main>div{padding:28px 24px 24px}}`;
+    const body = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">` +
+        `<title>${escape(title)}</title><style nonce="${nonce}">${style}</style></head>` +
+        `<body><main><div>${LOCKUP.replace('<svg ', '<svg class="lockup" ')}` +
+        `<p class="eyebrow">Invited CLI · <b>${tone}</b></p>` +
+        `<h1>${escape(title)}</h1><p>${escape(message)}</p></div></main></body></html>`;
+    response.writeHead(status, {
+        'Content-Type': 'text/html; charset=utf-8',
+        'Cache-Control': 'no-store',
+        'Content-Security-Policy': `default-src 'none'; style-src 'nonce-${nonce}'`,
+        'X-Content-Type-Options': 'nosniff',
+        'Referrer-Policy': 'no-referrer',
+        Connection: 'close',
+    });
+    response.end(body, after);
+}
+export async function listenForCallback(options) {
+    let settle;
+    const outcome = new Promise(resolve => (settle = resolve));
+    let finished = false;
+    let answered = null;
+    let lingerTimer;
+    const server = createServer((request, response) => {
+        const host = `127.0.0.1:${port}`;
+        if (finished) {
+            // The same answer again (a browser retrying its navigation) sees the
+            // same page; anything else learns the sign-in is over.
+            const again = new URL(request.url ?? '/', `http://${host}`);
+            if (answered && again.pathname === '/callback' && again.searchParams.get('state') === options.state)
+                return page(response, answered.status, answered.title, answered.message);
+            return page(response, 410, 'Already finished', 'This sign-in has finished. Return to the terminal.');
+        }
+        if (request.headers.host !== host)
+            return page(response, 400, 'Not this sign-in', 'This address is only for the Invited CLI on this computer.');
+        if (request.method !== 'GET')
+            return page(response, 405, 'Not allowed', 'Return to the terminal.');
+        const url = new URL(request.url ?? '/', `http://${host}`);
+        if (url.pathname !== '/callback')
+            return page(response, 404, 'Not found', 'Return to the terminal.');
+        const query = url.searchParams;
+        // Another request (a stray tab, a page probing ports) changes nothing.
+        if (query.getAll('state').length !== 1 || query.get('state') !== options.state)
+            return page(response, 400, 'Not this sign-in', 'This answer does not belong to the sign-in the terminal started. Return to the terminal.');
+        const finish = (status, title, message, result) => {
+            finished = true;
+            answered = { status, title, message };
+            page(response, status, title, message, () => settle(result));
+        };
+        const iss = query.get('iss');
+        if ((options.requireIss && iss === null) || (iss !== null && iss !== options.issuer))
+            return finish(400, 'Refused', 'The answer did not come from Invited. Return to the terminal.', {
+                ok: false,
+                message: `The browser's answer came from ${iss ?? 'an unnamed server'}, not ${options.issuer}, so it was refused. Run \`invited login\` again.`,
+            });
+        const error = query.get('error');
+        if (error !== null) {
+            const description = query.get('error_description');
+            return finish(400, 'Not connected', 'The Invited CLI was not connected. Return to the terminal.', {
+                ok: false,
+                message: error === 'access_denied'
+                    ? 'You cancelled the connection in your browser, so nothing was connected.'
+                    : `Invited did not connect the CLI (${error}${description ? ': ' + description : ''}).`,
+            });
+        }
+        const code = query.get('code');
+        if (!code)
+            return finish(400, 'Not connected', 'The answer had no code. Return to the terminal.', {
+                ok: false,
+                message: 'The browser came back without a sign-in code. Run `invited login` again.',
+            });
+        return finish(200, 'Invited CLI connected', 'You can close this tab and return to the terminal.', {
+            ok: true,
+            code,
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    const port = server.address().port;
+    const timer = setTimeout(() => {
+        finished = true;
+        settle({
+            ok: false,
+            message: `No answer came from your browser within ${duration(options.timeoutMs)}. Run \`invited login\` again.`,
+        });
+        close();
+    }, options.timeoutMs);
+    /** Once the browser has been answered, closing lingers a moment: the page
+     * finishes reaching the browser (it was once cut off mid-response), and a
+     * browser that retries its navigation gets the same page again instead of
+     * "This site can't be reached". The time limit closes at once. */
+    function close(force = false) {
+        clearTimeout(timer);
+        if (!force && answered) {
+            lingerTimer ??= setTimeout(() => close(true), options.lingerMs ?? 1_500);
+            return;
+        }
+        clearTimeout(lingerTimer);
+        server.close();
+        server.closeAllConnections();
+    }
+    return { redirectUri: `http://127.0.0.1:${port}/callback`, port, outcome, close: () => close() };
+}