@invitedlabs/cli 0.0.0-stage → 0.2.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 logs 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 logs in to Invited itself: in Cursor, open Customize > MCP, log 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 logs 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 logs in to Invited itself: start gemini and approve in your browser when it connects (/mcp auth invited logs 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, the Missing piece and the wordmark (public/brand/missing-piece/lockup-ink.svg, the Figma
+ * kit's drawing), drawn in the page's ink. */
+const LOCKUP = '<svg viewBox="69 90.25 394.75 105.75" fill="none" xmlns="http://www.w3.org/2000/svg" aria-label="Invited" role="img">' +
+    '<path fill-rule="evenodd" clip-rule="evenodd" d="M70.2305 150.001C70.2305 161.904 74.9589 173.319 83.3755 181.736C91.7921 190.153 103.208 194.881 115.11 194.881C127.013 194.881 138.429 190.153 146.845 181.736C155.262 173.319 159.99 161.904 159.99 150.001C159.99 138.098 155.262 126.683 146.845 118.266C138.429 109.85 127.013 105.121 115.11 105.121C103.208 105.121 91.7921 109.85 83.3755 118.266C74.9589 126.683 70.2305 138.098 70.2305 150.001ZM118.898 129.349C118.898 125.521 119.959 124.453 123.794 124.453H135.762C139.59 124.453 140.658 125.521 140.658 129.349V141.317C140.658 145.153 139.59 146.213 135.762 146.213H123.794C119.959 146.213 118.898 145.153 118.898 141.317V129.349Z" fill="currentColor"/>' +
+    '<path d="M149.268 100.665C148.336 96.9456 149.111 95.6604 152.831 94.7288L164.445 91.832C168.165 90.9072 169.45 91.6824 170.382 95.402L173.278 107.016C174.203 110.736 173.428 112.021 169.708 112.946L158.094 115.843C154.374 116.774 153.089 115.999 152.164 112.28L149.268 100.665Z" fill="currentColor"/>' +
+    '<path d="M211.085 184.179H198.029V115.827H211.085V184.179ZM261.975 184.179H249.591V153.843C249.591 147.123 247.191 143.763 241.143 143.763C234.615 143.763 230.391 148.467 230.391 156.531V184.179H218.007V134.643H229.815V142.707C232.503 137.427 236.919 133.683 244.983 133.683C256.311 133.683 261.975 139.443 261.975 151.443V184.179ZM295.223 184.179H280.247L261.911 134.643H274.871L287.735 173.331L300.599 134.643H313.559L295.223 184.179ZM328.225 184.179H315.841V134.643H328.225V184.179ZM322.081 127.251C317.473 127.251 314.881 124.467 314.881 120.819C314.881 117.171 317.473 114.387 322.081 114.387C326.689 114.387 329.185 117.171 329.185 120.819C329.185 124.467 326.689 127.251 322.081 127.251ZM353.535 184.659C342.303 184.659 338.559 181.203 338.559 170.259V143.475H330.783V134.643H338.559V119.667H350.943V134.643H361.695V143.475H350.943V170.739C350.943 174.579 352.575 175.923 356.511 175.923L361.695 175.827V184.179C359.679 184.371 355.743 184.659 353.535 184.659ZM386.843 185.139C370.715 185.139 361.691 175.059 361.691 159.411C361.691 144.147 370.331 133.683 386.267 133.683C402.299 133.683 410.939 144.243 410.939 158.835C410.939 159.891 410.843 160.851 410.747 162.003H374.075C374.459 172.083 379.259 176.691 386.843 176.691C392.987 176.691 397.019 173.619 398.459 168.531H409.883C407.771 178.707 400.187 185.139 386.843 185.139ZM386.267 142.131C379.451 142.131 375.131 146.067 374.075 153.939H398.555C397.499 146.067 393.083 142.131 386.267 142.131ZM435.073 185.139C421.729 185.139 413.281 175.635 413.281 159.411C413.281 143.187 421.729 133.683 435.073 133.683C442.561 133.683 447.553 136.755 450.337 142.131V115.827H462.721V184.179H450.912V175.731C448.225 181.491 443.329 185.139 435.073 185.139ZM437.953 175.731C445.345 175.731 450.337 170.739 450.337 159.411C450.337 148.083 445.345 143.091 437.953 143.091C430.657 143.091 425.665 148.083 425.665 159.411C425.665 170.739 430.657 175.731 437.953 175.731Z" 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(70px,23vw,107px);height:auto;margin:0 0 28px;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 log-in has finished. Return to the terminal.');
+        }
+        if (request.headers.host !== host)
+            return page(response, 400, 'Not this log-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 log-in', 'This answer does not belong to the log-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 log-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() };
+}