@dollhousemcp/mcp-server 2.0.10 → 2.0.11

package/dist/web/console/consoleToken.js

@@ -0,0 +1,930 @@
+/**
+ * Console session token storage and verification (#1780).
+ *
+ * Manages the file at `~/.dollhouse/run/console-token.auth.json` which
+ * holds the Bearer tokens that authenticate requests to the web console.
+ * The file is created on first leader election and persists across
+ * restarts — tokens only rotate when explicitly requested.
+ *
+ * The `.auth` filename suffix keeps this state isolated from any legacy
+ * no-authentication DollhouseMCP installation running on the same
+ * machine. The port, lock file, and token file all share the same
+ * isolation strategy — see `src/config/env.ts` for the port, and
+ * `LeaderElection.ts` for the lock file.
+ *
+ * Schema is forward-compatible with multi-device, multi-tenant, and
+ * scope-restricted tokens for Phase 2+. Phase 1 uses a single "console"
+ * kind token and stubs the scope/boundary checks.
+ *
+ * File format (version 1):
+ * ```json
+ * {
+ *   "version": 1,
+ *   "tokens": [
+ *     {
+ *       "id": "018e1a2b-...",
+ *       "name": "Kermit on mick-MacBook-Pro",
+ *       "kind": "console",
+ *       "token": "<64-hex>",
+ *       "scopes": ["admin"],
+ *       "elementBoundaries": null,
+ *       "tenant": null,
+ *       "platform": "local",
+ *       "labels": {},
+ *       "createdAt": "2026-04-04T20:00:00.000Z",
+ *       "lastUsedAt": null,
+ *       "createdVia": "initial-setup"
+ *     }
+ *   ],
+ *   "totp": { "enrolled": false, "secret": null, "backupCodes": [] }
+ * }
+ * ```
+ *
+ * @since v2.1.0 — Issue #1780
+ */
+import { homedir, hostname, platform } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, readFile, rename, writeFile, chmod, unlink, copyFile } from 'node:fs/promises';
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import { Secret, TOTP } from 'otpauth';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { logger } from '../../utils/logger.js';
+/** Directory for runtime state files — same as LeaderElection. */
+const RUN_DIR = join(homedir(), '.dollhouse', 'run');
+/**
+ * Default path to the authenticated console's token file.
+ *
+ * The `.auth` suffix isolates this from any legacy no-authentication
+ * DollhouseMCP installation that may also be running on the same
+ * machine. Legacy installs did not write a token file at all; the
+ * authenticated console writes `console-token.auth.json`. Combined with
+ * the port and lock-file separation, this gives the two generations of
+ * the console fully independent state trees under `~/.dollhouse/run/`.
+ *
+ * Callers can override via `DOLLHOUSE_CONSOLE_TOKEN_FILE` in the env.
+ */
+const DEFAULT_TOKEN_FILE = join(RUN_DIR, 'console-token.auth.json');
+/** Current token file schema version. */
+const TOKEN_FILE_VERSION = 1;
+/** Token length in bytes (produces a 64-character hex string). */
+const TOKEN_BYTES = 32;
+/** File mode for the token file — owner read/write only. */
+const TOKEN_FILE_MODE = 0o600;
+/**
+ * TOTP configuration — RFC 6238 defaults. These are compiled-in so the
+ * otpauth URI is deterministic and compatible with every common authenticator
+ * app (Google Authenticator, 1Password, Authy, Bitwarden, etc.).
+ */
+const TOTP_ISSUER = 'DollhouseMCP';
+const TOTP_ALGORITHM = 'SHA1';
+const TOTP_DIGITS = 6;
+const TOTP_PERIOD_SECONDS = 30;
+const TOTP_SECRET_SIZE_BYTES = 20; // 160 bits — the RFC 6238 recommendation
+/**
+ * ±2 time step tolerance (±60s drift) → 150 second total validity window.
+ *
+ * The naive choice would be `window: 1` (±30s, 90s total) which is the RFC
+ * 6238 default and matches most web login flows where the user types a code
+ * they just generated, with sub-second latency to the server. That doesn't
+ * cover our real deployment profile:
+ *
+ * 1. **Async bridge flows** — DollhouseBridge over Zulip (or similar chat
+ *    transports) can add 10-60 seconds of latency between the user typing
+ *    the code and the MCP server verifying it. A code typed with a few
+ *    seconds of lifetime remaining can slide out of the validation window
+ *    before reaching the server.
+ *
+ * 2. **Clock drift** — containers, VMs, and phones with lazy NTP can
+ *    disagree with the server by tens of seconds. ±30s gives zero margin
+ *    against any drift at all.
+ *
+ * `window: 2` gives 5 valid codes out of 10^6 per attempt (vs. 3 with
+ * window=1). Combined with the 10/min rate limiter and the always-on auth
+ * gate, brute-force success probability remains below 5e-5 per minute —
+ * well within the security envelope. `window: 3` (±90s, 210s total) is
+ * defensible but reserved for future deployment pressure; easier to widen
+ * later than to narrow later.
+ *
+ * Note: the window is anchored to the **server's verification clock**, not
+ * the user's code-generation clock. When a user complains that a code they
+ * "just typed" was rejected, the error message nudges them to submit codes
+ * with plenty of step-lifetime remaining.
+ */
+const TOTP_VALIDATE_WINDOW = 2;
+/**
+ * Error message for a failed TOTP code check. Includes a hint about the
+ * common failure mode (code aged out in transit) so users on high-latency
+ * channels know what to try differently on retry.
+ */
+const INVALID_TOTP_MESSAGE = 'Invalid TOTP code. When copying from an authenticator app, use a code ' +
+    'with plenty of lifetime remaining — codes can age out in transit on ' +
+    'slower channels (e.g. chat bridges). Wait for a fresh code if unsure.';
+/** Pending enrollments expire this long after begin() to limit in-memory secret lifetime. */
+const TOTP_PENDING_TTL_MS = 10 * 60 * 1000; // 10 minutes
+/**
+ * Hard cap on concurrent pending enrollments. An authenticated caller who
+ * misbehaves could otherwise fill the in-memory Map with 10-minute-TTL
+ * secrets. Realistic users need at most 1 pending enrollment at a time;
+ * 10 is generous headroom for retry-during-enrollment scenarios.
+ *
+ * When the cap is hit, `beginTotpEnrollment` throws `TOO_MANY_PENDING`
+ * (mapped to HTTP 429). Rejecting loudly is preferred over silently
+ * evicting someone else's legitimate pending entry.
+ */
+const MAX_PENDING_ENROLLMENTS = 10;
+/**
+ * Grace window for old tokens after rotation — 15 seconds.
+ *
+ * After a rotation, the previous token value stays valid for this period to
+ * cover in-flight requests from the rotating tab and any other local processes
+ * that read the token file but haven't picked up the new value yet. All
+ * consumers are loopback-only (127.0.0.1), so network latency is negligible
+ * and 15s is generous.
+ *
+ * Grace entries are per-rotation and in-memory only — they are never persisted
+ * to disk. A leader crash kills all grace entries, which is the safe failure
+ * mode (callers re-auth with the new token from the file).
+ */
+const ROTATION_GRACE_MS = 15_000;
+/** Number of backup codes generated on enrollment. */
+const BACKUP_CODE_COUNT = 10;
+/** Characters per backup code — Crockford base32-ish, no ambiguous chars. */
+const BACKUP_CODE_LENGTH = 8;
+/**
+ * Backup code alphabet — Crockford base32 (32 chars, excludes I/L/O/U).
+ * 5 bits per char × 8 chars = 40 bits per code, plenty for one-shot use.
+ */
+const BACKUP_CODE_ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+/**
+ * Strict format for console tokens — 64 lowercase hex characters.
+ * Used as a defense-in-depth check in verify(): even if the caller forgot
+ * to sanitize the presented value, we reject anything that isn't a legitimate
+ * 256-bit hex token before reaching the constant-time comparison.
+ * DMCP-SEC-004 mitigation.
+ */
+const TOKEN_FORMAT = /^[0-9a-f]{64}$/;
+/**
+ * Typed error for TOTP store operations. Carries a machine-readable
+ * `code` field so the HTTP layer can map failures to consistent response
+ * codes without parsing free-form error messages. Callers (CLI, UI) can
+ * branch on `code` instead of the human-readable `message`.
+ */
+export class TotpError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'TotpError';
+    }
+}
+/**
+ * Generate a cryptographically random token.
+ * Returns 64 hex characters (256 bits of entropy).
+ */
+function generateTokenValue() {
+    return randomBytes(TOKEN_BYTES).toString('hex');
+}
+/**
+ * Mask a token for display — shows first 8 chars only.
+ */
+function maskToken(token) {
+    if (token.length <= 8)
+        return '••••••••';
+    return `${token.slice(0, 8)}${'•'.repeat(Math.min(56, token.length - 8))}`;
+}
+/**
+ * Build a human-readable default name from a puppet name and the machine hostname.
+ * Example: "Kermit on mick-MacBook-Pro".
+ *
+ * The puppet name is passed in rather than imported to avoid a circular dependency
+ * with SessionNames (which only generates per-process names).
+ */
+function defaultTokenName(puppetName) {
+    const host = hostname() || 'localhost';
+    return `${puppetName} on ${host}`;
+}
+/**
+ * Generate a batch of random backup codes. Each code is `BACKUP_CODE_LENGTH`
+ * characters drawn uniformly from `BACKUP_CODE_ALPHABET` (Crockford base32,
+ * 32 characters, 5 bits per char). Uses rejection sampling against 256-bit
+ * random bytes to avoid modulo bias.
+ */
+function generateBackupCodes() {
+    // 32-char alphabet divides 256 evenly (256 / 32 = 8), so the simple
+    // mod-32 mapping has no bias. Generate one byte per character.
+    const codes = [];
+    for (let i = 0; i < BACKUP_CODE_COUNT; i++) {
+        const bytes = randomBytes(BACKUP_CODE_LENGTH);
+        let code = '';
+        for (let j = 0; j < BACKUP_CODE_LENGTH; j++) {
+            code += BACKUP_CODE_ALPHABET[bytes[j] & 0x1f];
+        }
+        codes.push(code);
+    }
+    return codes;
+}
+/**
+ * Hash a backup code for storage. sha256 hex is plenty — these codes are
+ * high-entropy (40 bits) and we only need to detect a tamper, not resist
+ * password-cracking on a leaked hash.
+ */
+function hashBackupCode(code) {
+    return createHash('sha256').update(code, 'utf8').digest('hex');
+}
+/**
+ * Normalize a user-entered backup code before hashing: uppercase, strip
+ * whitespace, strip dashes (users often type codes in groups like
+ * "XXXX-XXXX"). Returns the canonical form that matches what we stored.
+ */
+function normalizeBackupCode(raw) {
+    return raw.replaceAll(/[\s-]/g, '').toUpperCase();
+}
+/**
+ * Build the full otpauth:// URI for a given secret and display label.
+ * The label is URI-encoded by `otpauth` internally via URIComponent.
+ */
+function buildTotpUri(secret, label) {
+    const totp = new TOTP({
+        issuer: TOTP_ISSUER,
+        label,
+        algorithm: TOTP_ALGORITHM,
+        digits: TOTP_DIGITS,
+        period: TOTP_PERIOD_SECONDS,
+        secret,
+    });
+    return totp.toString();
+}
+/**
+ * Validate a single token entry object. Returns true if the entry has all
+ * required fields with the correct types. Extracted from validateTokenFile
+ * to keep the top-level validator's cognitive complexity manageable.
+ */
+function isValidTokenEntry(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    const e = raw;
+    return (typeof e.id === 'string' && e.id.length > 0 &&
+        typeof e.name === 'string' &&
+        typeof e.token === 'string' && e.token.length > 0 &&
+        typeof e.kind === 'string' &&
+        Array.isArray(e.scopes) &&
+        typeof e.createdAt === 'string');
+}
+/**
+ * Validate that a parsed JSON object conforms to the expected token file schema.
+ * Returns a typed ConsoleTokenFile or null if invalid.
+ *
+ * Strict validation — an unrecognized version or missing required fields
+ * causes the file to be treated as corrupt so a fresh one can be written.
+ */
+function validateTokenFile(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const obj = raw;
+    if (obj.version !== TOKEN_FILE_VERSION)
+        return null;
+    if (!Array.isArray(obj.tokens))
+        return null;
+    if (!obj.totp || typeof obj.totp !== 'object')
+        return null;
+    if (!obj.tokens.every(isValidTokenEntry))
+        return null;
+    return raw;
+}
+/**
+ * Stateful store that owns the console token file and verifies presented tokens.
+ *
+ * Designed to live on the leader process. Followers should not construct this —
+ * they read the file directly via `readTokenFileRaw()` for their own HTTP calls.
+ */
+export class ConsoleTokenStore {
+    filePath;
+    data = null;
+    /**
+     * Pre-converted Buffer cache keyed by entry id. Populated whenever `this.data`
+     * is assigned (load, create, future rotation). Verify() reuses the stored
+     * buffers so the hot path doesn't re-allocate per-token on every request.
+     * Negligible win with 1 token today; meaningful with Phase 2 multi-token
+     * lookups. Not serialized — buffers are never written to disk.
+     */
+    tokenBuffers = new Map();
+    /**
+     * In-memory pending TOTP enrollments, keyed by opaque pendingId. Nothing
+     * lives on disk until confirmTotpEnrollment() succeeds, which limits the
+     * window in which a half-completed enrollment leaks a secret via file read.
+     * Entries expire after TOTP_PENDING_TTL_MS (#1794).
+     */
+    pendingEnrollments = new Map();
+    /**
+     * In-memory grace buffer for recently-rotated tokens (#1795). After a
+     * rotation, the old token value is stashed here with a per-rotation expiry
+     * so in-flight requests that were sent before the rotation response arrived
+     * still authenticate. Entries are per-rotation (concurrent rotations each
+     * get their own grace slot) and never persisted to disk.
+     */
+    graceEntries = [];
+    constructor(filePath = DEFAULT_TOKEN_FILE) {
+        this.filePath = filePath;
+    }
+    /**
+     * Rebuild the token buffer cache after a data load, create, or mutation.
+     * Keeps the hot verify() path allocation-free for the stored side.
+     */
+    rebuildTokenBuffers() {
+        this.tokenBuffers.clear();
+        if (!this.data)
+            return;
+        for (const entry of this.data.tokens) {
+            this.tokenBuffers.set(entry.id, Buffer.from(entry.token, 'utf8'));
+        }
+    }
+    /**
+     * Read the existing token file, or create a new one with a single initial
+     * token if none exists. Idempotent — safe to call on every leader election.
+     *
+     * @param puppetName - A puppet name picked by the caller (e.g. from SessionNames)
+     *                     used to build the default display name on first run.
+     * @returns The primary (first) token entry — convenient for server startup
+     *          to inject into HTML and stamp on followers.
+     */
+    async ensureInitialized(puppetName) {
+        const readResult = await this.readWithStatus();
+        if (readResult.status === 'ok' && readResult.data.tokens.length > 0) {
+            this.data = readResult.data;
+            this.rebuildTokenBuffers();
+            logger.debug('[ConsoleToken] Loaded existing token file', {
+                path: this.filePath,
+                count: readResult.data.tokens.length,
+            });
+            return readResult.data.tokens[0];
+        }
+        // If the file existed but was corrupt, back it up before overwriting.
+        // Users may have hand-edited the file with custom names/labels — don't
+        // destroy their data silently. A timestamped copy lets them recover.
+        if (readResult.status === 'corrupt') {
+            await this.backupCorruptFile();
+        }
+        // Create a fresh file with one initial token
+        const now = new Date().toISOString();
+        const initial = {
+            id: randomUUID(),
+            name: defaultTokenName(puppetName),
+            kind: 'console',
+            token: generateTokenValue(),
+            scopes: ['admin'],
+            elementBoundaries: null,
+            tenant: null,
+            platform: 'local',
+            labels: {},
+            createdAt: now,
+            lastUsedAt: null,
+            createdVia: 'initial-setup',
+        };
+        const file = {
+            version: TOKEN_FILE_VERSION,
+            tokens: [initial],
+            totp: { enrolled: false, secret: null, backupCodes: [], enrolledAt: null },
+        };
+        await this.write(file);
+        this.data = file;
+        this.rebuildTokenBuffers();
+        logger.info('[ConsoleToken] Created new token file', {
+            path: this.filePath,
+            id: initial.id,
+            name: initial.name,
+        });
+        return initial;
+    }
+    /**
+     * Verify a presented Bearer token against the stored entries.
+     * Uses timing-safe comparison to prevent side-channel attacks.
+     *
+     * Updates `lastUsedAt` on the matched entry (in memory only; disk write
+     * is debounced to avoid disk thrash on every request — Phase 2 feature).
+     *
+     * @returns The matching entry, or null if no match.
+     */
+    verify(presented) {
+        if (!this.data || !presented)
+            return null;
+        // DMCP-SEC-004: Normalize the presented token to NFC and validate the
+        // strict hex format before any comparison. This blocks Unicode abuse
+        // (homographs, zero-width, bidi overrides) from reaching timingSafeEqual.
+        // Defense-in-depth — the middleware already sanitizes, but verify() is a
+        // public API that any future caller could invoke directly.
+        const normalized = UnicodeValidator.normalize(presented).normalizedContent;
+        if (!TOKEN_FORMAT.test(normalized))
+            return null;
+        // Only the presented side is allocated per-request; stored buffers are
+        // pre-converted in the tokenBuffers cache so the hot loop is allocation-free.
+        const presentedBuf = Buffer.from(normalized, 'utf8');
+        for (const entry of this.data.tokens) {
+            const storedBuf = this.tokenBuffers.get(entry.id);
+            if (!storedBuf || storedBuf.length !== presentedBuf.length)
+                continue;
+            if (timingSafeEqual(presentedBuf, storedBuf)) {
+                entry.lastUsedAt = new Date().toISOString();
+                return entry;
+            }
+        }
+        // Check grace buffer — recently-rotated tokens that haven't expired yet.
+        // Returns the primary entry on match so the caller gets the same admin
+        // shape; the grace window just extends the authentication period.
+        this.sweepExpiredGraceEntries();
+        for (const grace of this.graceEntries) {
+            if (grace.buf.length === presentedBuf.length && timingSafeEqual(presentedBuf, grace.buf)) {
+                // Touch the primary entry — the request is still "using" this token slot.
+                if (this.data.tokens.length > 0) {
+                    this.data.tokens[0].lastUsedAt = new Date().toISOString();
+                }
+                return this.data.tokens[0] ?? null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get the primary token value for injection into HTML or forwarder config.
+     * Returns the first entry's token string, or null if uninitialized.
+     */
+    getPrimaryTokenValue() {
+        if (!this.data || this.data.tokens.length === 0)
+            return null;
+        return this.data.tokens[0].token;
+    }
+    /**
+     * Return all tokens with the secret value masked — safe to serialize for
+     * the Security tab UI or `GET /api/console/token/info` responses.
+     */
+    listMasked() {
+        if (!this.data)
+            return [];
+        return this.data.tokens.map(({ token, ...rest }) => ({
+            ...rest,
+            tokenPreview: maskToken(token),
+        }));
+    }
+    /**
+     * Get the path to the token file on disk.
+     */
+    getFilePath() {
+        return this.filePath;
+    }
+    // --------------------------------------------------------------------
+    // TOTP — Phase 2 (#1794)
+    // --------------------------------------------------------------------
+    /**
+     * Returns a safe-to-serialize view of TOTP enrollment state. Never leaks
+     * the secret or any backup code material.
+     */
+    getTotpStatus() {
+        const totp = this.data?.totp;
+        if (!totp?.enrolled) {
+            return { enrolled: false, enrolledAt: null, backupCodesRemaining: 0 };
+        }
+        return {
+            enrolled: true,
+            enrolledAt: totp.enrolledAt ?? null,
+            backupCodesRemaining: totp.backupCodes.length,
+        };
+    }
+    /** Convenience: true if the user has a confirmed TOTP secret. */
+    isTotpEnrolled() {
+        return Boolean(this.data?.totp?.enrolled && this.data.totp.secret);
+    }
+    /**
+     * Begin a TOTP enrollment. Generates a fresh secret, holds it in the
+     * in-memory pending map, and returns the data the UI needs to render a
+     * QR code and manual-entry fallback. Nothing is persisted until
+     * `confirmTotpEnrollment` succeeds.
+     *
+     * Callers may call this multiple times; each call produces a new pendingId
+     * and secret. Old pending entries expire after TOTP_PENDING_TTL_MS.
+     *
+     * @throws Error if TOTP is already enrolled — callers must disable first.
+     */
+    beginTotpEnrollment(label) {
+        if (this.isTotpEnrolled()) {
+            throw new TotpError('TOTP is already enrolled — disable existing enrollment before enrolling again', 'ALREADY_ENROLLED');
+        }
+        this.sweepExpiredEnrollments();
+        // Reject if we're already at the per-process cap on concurrent pendings.
+        // Sweep ran above, so any slot still held is a live, unexpired enrollment
+        // belonging to somebody else — evicting it could silently kill their flow.
+        if (this.pendingEnrollments.size >= MAX_PENDING_ENROLLMENTS) {
+            throw new TotpError(`Too many pending enrollments (max ${MAX_PENDING_ENROLLMENTS}); wait for existing pendings to expire or be confirmed`, 'TOO_MANY_PENDING');
+        }
+        // Derive a display label from the primary token name if the caller
+        // didn't provide one. Authenticator apps show "<Issuer>:<label>", so
+        // including the token name gives multi-device users a way to tell
+        // enrollments apart.
+        const displayLabel = label
+            ?? this.data?.tokens[0]?.name
+            ?? 'console';
+        const secret = new Secret({ size: TOTP_SECRET_SIZE_BYTES });
+        const pendingId = randomUUID();
+        const expiresAt = Date.now() + TOTP_PENDING_TTL_MS;
+        this.pendingEnrollments.set(pendingId, {
+            secret: secret.base32,
+            label: displayLabel,
+            expiresAt,
+        });
+        logger.debug('[ConsoleToken] TOTP enrollment begun', { pendingId, label: displayLabel });
+        return {
+            pendingId,
+            secret: secret.base32,
+            otpauthUri: buildTotpUri(secret, displayLabel),
+            expiresAt,
+        };
+    }
+    /**
+     * Confirm a pending TOTP enrollment. Verifies the code against the pending
+     * secret; on success, generates 10 plaintext backup codes, hashes them for
+     * storage, and persists the enrollment. Returns the plaintext backup codes
+     * exactly once — the caller is responsible for showing them to the user
+     * and then discarding them.
+     *
+     * Wrong codes do NOT consume or invalidate the pending enrollment — the
+     * user can retry until it expires. This matches user expectations for
+     * "oops, typed the wrong code" and limits the damage from a fat-fingered
+     * first attempt.
+     *
+     * @throws Error if pendingId is unknown, expired, or code invalid.
+     */
+    async confirmTotpEnrollment(pendingId, code) {
+        if (!this.data) {
+            throw new TotpError('Token store not initialized', 'STORE_NOT_INITIALIZED');
+        }
+        this.sweepExpiredEnrollments();
+        const pending = this.pendingEnrollments.get(pendingId);
+        if (!pending) {
+            throw new TotpError('Pending enrollment not found or expired', 'PENDING_NOT_FOUND');
+        }
+        // Verify the presented code against the pending secret. `validate` returns
+        // the time-step delta (a number, possibly 0) on match, or null on mismatch.
+        const totp = new TOTP({
+            issuer: TOTP_ISSUER,
+            label: pending.label,
+            algorithm: TOTP_ALGORITHM,
+            digits: TOTP_DIGITS,
+            period: TOTP_PERIOD_SECONDS,
+            secret: Secret.fromBase32(pending.secret),
+        });
+        const sanitized = code.replaceAll(/\s/g, '');
+        const delta = totp.validate({ token: sanitized, window: TOTP_VALIDATE_WINDOW });
+        if (delta === null) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'TOTP_VERIFICATION_FAILED',
+                severity: 'MEDIUM',
+                source: 'ConsoleTokenStore.confirmTotpEnrollment',
+                details: 'Pending TOTP enrollment failed code verification',
+            });
+            throw new TotpError(INVALID_TOTP_MESSAGE, 'INVALID_TOTP_CODE');
+        }
+        // Code is valid — commit enrollment.
+        const plaintextCodes = generateBackupCodes();
+        const hashedCodes = plaintextCodes.map(hashBackupCode);
+        const enrolledAt = new Date().toISOString();
+        this.data.totp = {
+            enrolled: true,
+            secret: pending.secret,
+            backupCodes: hashedCodes,
+            enrolledAt,
+        };
+        await this.write(this.data);
+        this.pendingEnrollments.delete(pendingId);
+        logger.info('[ConsoleToken] TOTP enrollment confirmed', {
+            enrolledAt,
+            backupCodes: hashedCodes.length,
+        });
+        SecurityMonitor.logSecurityEvent({
+            type: 'TOTP_ENROLLED',
+            severity: 'MEDIUM',
+            source: 'ConsoleTokenStore.confirmTotpEnrollment',
+            details: 'Console TOTP second factor enrolled',
+            additionalData: { enrolledAt, backupCodes: hashedCodes.length },
+        });
+        return { backupCodes: plaintextCodes, enrolledAt };
+    }
+    /**
+     * Verify a user-presented code. Accepts either a live TOTP code or a
+     * single-use backup code. On successful backup-code match, the consumed
+     * code's hash is removed from storage and the file is re-written.
+     *
+     * Returns a discriminated result so the caller can distinguish "consumed
+     * a backup code" (which the UI should surface with a warning about
+     * remaining count) from "valid TOTP code" (normal case). Returns
+     * `{ ok: false }` on any failure — the caller should not retry within
+     * the same request lifecycle.
+     */
+    async verifyTotp(code) {
+        if (!this.data?.totp?.enrolled || !this.data.totp.secret) {
+            return { ok: false };
+        }
+        const sanitized = code.replaceAll(/\s/g, '');
+        if (!sanitized)
+            return { ok: false };
+        // Try live TOTP first — fast path, no disk write.
+        const totp = new TOTP({
+            issuer: TOTP_ISSUER,
+            label: this.data.tokens[0]?.name ?? 'console',
+            algorithm: TOTP_ALGORITHM,
+            digits: TOTP_DIGITS,
+            period: TOTP_PERIOD_SECONDS,
+            secret: Secret.fromBase32(this.data.totp.secret),
+        });
+        if (totp.validate({ token: sanitized, window: TOTP_VALIDATE_WINDOW }) !== null) {
+            return { ok: true, method: 'totp', backupCodesRemaining: this.data.totp.backupCodes.length };
+        }
+        // Fall back to backup code — normalize, hash, constant-time search.
+        const normalizedInput = normalizeBackupCode(sanitized);
+        const inputHash = hashBackupCode(normalizedInput);
+        const inputHashBuf = Buffer.from(inputHash, 'hex');
+        let matchIndex = -1;
+        for (let i = 0; i < this.data.totp.backupCodes.length; i++) {
+            const storedBuf = Buffer.from(this.data.totp.backupCodes[i], 'hex');
+            if (storedBuf.length === inputHashBuf.length && timingSafeEqual(inputHashBuf, storedBuf)) {
+                matchIndex = i;
+                break;
+            }
+        }
+        if (matchIndex === -1) {
+            // Both TOTP and backup code paths exhausted without a match. Emit a
+            // single audit event so the security monitor can alert on aggregate
+            // failure rates (SecurityMonitor dedups the same type+source within
+            // a 60s window, so rapid-fire attacks are collapsed into one entry).
+            SecurityMonitor.logSecurityEvent({
+                type: 'TOTP_VERIFICATION_FAILED',
+                severity: 'MEDIUM',
+                source: 'ConsoleTokenStore.verifyTotp',
+                details: 'Presented TOTP code matched neither the live secret nor any backup code',
+            });
+            return { ok: false };
+        }
+        // Consume the matched backup code — remove from storage and persist.
+        this.data.totp.backupCodes.splice(matchIndex, 1);
+        await this.write(this.data);
+        logger.info('[ConsoleToken] Backup code consumed', {
+            remaining: this.data.totp.backupCodes.length,
+        });
+        SecurityMonitor.logSecurityEvent({
+            type: 'TOTP_BACKUP_CODE_CONSUMED',
+            severity: 'MEDIUM',
+            source: 'ConsoleTokenStore.verifyTotp',
+            details: 'TOTP backup code consumed for console authentication',
+            additionalData: { remaining: this.data.totp.backupCodes.length },
+        });
+        return { ok: true, method: 'backup', backupCodesRemaining: this.data.totp.backupCodes.length };
+    }
+    /**
+     * Disable TOTP. Requires a valid code (TOTP or backup) as confirmation so
+     * an attacker who momentarily has access to a live session can't silently
+     * strip the second factor.
+     *
+     * @throws Error if not enrolled or code invalid.
+     */
+    async disableTotp(code) {
+        if (!this.data) {
+            throw new TotpError('Token store not initialized', 'STORE_NOT_INITIALIZED');
+        }
+        if (!this.isTotpEnrolled()) {
+            throw new TotpError('TOTP is not currently enrolled', 'NOT_ENROLLED');
+        }
+        const result = await this.verifyTotp(code);
+        if (!result.ok) {
+            throw new TotpError(INVALID_TOTP_MESSAGE, 'INVALID_TOTP_CODE');
+        }
+        this.data.totp = {
+            enrolled: false,
+            secret: null,
+            backupCodes: [],
+            enrolledAt: null,
+        };
+        await this.write(this.data);
+        logger.info('[ConsoleToken] TOTP disabled');
+        SecurityMonitor.logSecurityEvent({
+            type: 'TOTP_DISABLED',
+            severity: 'HIGH',
+            source: 'ConsoleTokenStore.disableTotp',
+            details: 'Console TOTP second factor disabled — single-factor auth restored',
+        });
+    }
+    /** Remove any pending enrollments whose TTL has passed. */
+    sweepExpiredEnrollments() {
+        const now = Date.now();
+        for (const [id, pending] of this.pendingEnrollments) {
+            if (pending.expiresAt <= now) {
+                this.pendingEnrollments.delete(id);
+            }
+        }
+    }
+    // --------------------------------------------------------------------
+    // end TOTP
+    // --------------------------------------------------------------------
+    // --------------------------------------------------------------------
+    // Token rotation — #1795
+    // --------------------------------------------------------------------
+    /**
+     * Rotate the primary console token. Requires TOTP confirmation (Pattern B).
+     *
+     * Flow:
+     * 1. Verify the confirmation code via `verifyTotp()` (live TOTP or backup code).
+     * 2. Stash the old token value in the in-memory grace buffer so in-flight
+     *    requests from the rotating tab (and any other local process that read
+     *    the file before the rotation) still authenticate for ROTATION_GRACE_MS.
+     * 3. Generate a new 32-byte token, mutate the primary entry in place, write
+     *    the file atomically, and rebuild the buffer cache.
+     * 4. Return the new token inline so the caller can update `DollhouseAuth.token`
+     *    without a page reload.
+     *
+     * Pattern A (OS dialog fallback for users without TOTP) is deferred — the
+     * caller should gate the UI so the rotate action is only available when
+     * TOTP is enrolled.
+     *
+     * @throws TotpError STORE_NOT_INITIALIZED — store never loaded
+     * @throws TotpError TOTP_REQUIRED — TOTP not enrolled, rotation requires second-factor confirmation
+     * @throws TotpError INVALID_TOTP_CODE — wrong code
+     */
+    async rotatePrimary(confirmationCode) {
+        if (!this.data) {
+            throw new TotpError('Token store not initialized', 'STORE_NOT_INITIALIZED');
+        }
+        if (!this.isTotpEnrolled()) {
+            throw new TotpError('Token rotation requires TOTP enrollment — enroll a second factor before rotating', 'TOTP_REQUIRED');
+        }
+        // Step 1: verify the confirmation code.
+        const verification = await this.verifyTotp(confirmationCode);
+        if (!verification.ok) {
+            throw new TotpError(INVALID_TOTP_MESSAGE, 'INVALID_TOTP_CODE');
+        }
+        // Step 2: stash the old token in the grace buffer.
+        const primary = this.data.tokens[0];
+        const graceDeadline = Date.now() + ROTATION_GRACE_MS;
+        this.sweepExpiredGraceEntries();
+        this.graceEntries.push({
+            buf: Buffer.from(primary.token, 'utf8'),
+            expiresAt: graceDeadline,
+        });
+        // Step 3: generate a new token, mutate the primary entry, persist.
+        const rotatedAt = new Date().toISOString();
+        primary.token = generateTokenValue();
+        primary.createdAt = rotatedAt;
+        primary.lastUsedAt = null;
+        primary.createdVia = 'rotation';
+        await this.write(this.data);
+        this.rebuildTokenBuffers();
+        logger.info('[ConsoleToken] Primary token rotated', {
+            id: primary.id,
+            rotatedAt,
+            graceMs: ROTATION_GRACE_MS,
+        });
+        SecurityMonitor.logSecurityEvent({
+            type: 'CONSOLE_TOKEN_ROTATED',
+            severity: 'HIGH',
+            source: 'ConsoleTokenStore.rotatePrimary',
+            details: 'Console primary token rotated via TOTP confirmation',
+            additionalData: {
+                tokenId: primary.id,
+                rotatedAt,
+                graceMs: ROTATION_GRACE_MS,
+                confirmationMethod: verification.method,
+            },
+        });
+        return {
+            token: primary.token,
+            rotatedAt,
+            graceUntil: graceDeadline,
+        };
+    }
+    /** Remove expired grace entries so they stop matching in verify(). */
+    sweepExpiredGraceEntries() {
+        const now = Date.now();
+        let i = 0;
+        while (i < this.graceEntries.length) {
+            if (this.graceEntries[i].expiresAt <= now) {
+                this.graceEntries.splice(i, 1);
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    // --------------------------------------------------------------------
+    // end rotation
+    // --------------------------------------------------------------------
+    /**
+     * Read the token file and distinguish missing from corrupt.
+     *
+     * Returning a tagged union lets `ensureInitialized()` back up corrupt files
+     * before overwriting them — users who hand-edited their tokens with custom
+     * names or labels deserve a recovery path instead of a silent destroy.
+     */
+    async readWithStatus() {
+        let content;
+        try {
+            content = await readFile(this.filePath, 'utf8');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return { status: 'missing' };
+            return { status: 'corrupt', reason: err instanceof Error ? err.message : String(err) };
+        }
+        try {
+            const parsed = JSON.parse(content);
+            const validated = validateTokenFile(parsed);
+            if (!validated)
+                return { status: 'corrupt', reason: 'schema validation failed' };
+            return { status: 'ok', data: validated };
+        }
+        catch (err) {
+            return { status: 'corrupt', reason: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    /**
+     * Copy the current (presumed corrupt) token file to a timestamped backup
+     * alongside it so the user can recover hand-edited data after an accidental
+     * syntax error. Best-effort — failure to back up does not block creating
+     * a fresh file, since the primary goal is keeping the console usable.
+     */
+    async backupCorruptFile() {
+        const timestamp = new Date().toISOString().replaceAll(/[:.]/g, '-');
+        const backupPath = `${this.filePath}.corrupt-${timestamp}`;
+        try {
+            await copyFile(this.filePath, backupPath);
+            logger.warn(`[ConsoleToken] Corrupt token file backed up to ${backupPath} — a fresh token will be created`);
+        }
+        catch (err) {
+            logger.warn('[ConsoleToken] Could not back up corrupt token file, will overwrite in place', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    /**
+     * Atomically write the token file with owner-only permissions.
+     * Uses temp+rename to avoid partial writes on crash.
+     *
+     * On Windows, `chmod(0o600)` is effectively a no-op because the file
+     * system uses ACLs instead of POSIX modes. We log a one-time warning so
+     * users on Windows know the token file does not have OS-enforced access
+     * control and can decide whether to use additional tooling (icacls, NTFS
+     * permissions, or a different storage location).
+     */
+    async write(file) {
+        await mkdir(RUN_DIR, { recursive: true });
+        const tmpFile = `${this.filePath}.${process.pid}.tmp`;
+        try {
+            await writeFile(tmpFile, JSON.stringify(file, null, 2), 'utf8');
+            await chmod(tmpFile, TOKEN_FILE_MODE);
+            await rename(tmpFile, this.filePath);
+            this.warnIfWindowsPermissions();
+        }
+        catch (err) {
+            try {
+                await unlink(tmpFile);
+            }
+            catch { /* ignore */ }
+            throw err;
+        }
+    }
+    /** One-shot flag so the Windows permissions warning is logged at most once. */
+    windowsWarningLogged = false;
+    warnIfWindowsPermissions() {
+        if (this.windowsWarningLogged)
+            return;
+        if (platform() !== 'win32')
+            return;
+        this.windowsWarningLogged = true;
+        logger.warn(`[ConsoleToken] Token file at ${this.filePath} has no OS-enforced access control on Windows ` +
+            `(chmod 0o600 is a no-op on this platform). Any process running as the same user can read the file. ` +
+            `Consider using NTFS ACLs via 'icacls' for stronger isolation in multi-user environments.`);
+    }
+}
+/**
+ * Read the raw token file from disk without constructing a store.
+ * Intended for follower processes that need the primary token to attach
+ * to their ingest POSTs. Returns null if the file does not exist or is invalid.
+ *
+ * @param filePath - Optional override for the token file location
+ */
+export async function readTokenFileRaw(filePath = DEFAULT_TOKEN_FILE) {
+    try {
+        const content = await readFile(filePath, 'utf8');
+        return validateTokenFile(JSON.parse(content));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the primary token value from the token file on disk.
+ * Convenience helper for followers and external consumers.
+ */
+export async function getPrimaryTokenFromFile(filePath = DEFAULT_TOKEN_FILE) {
+    const file = await readTokenFileRaw(filePath);
+    if (!file || file.tokens.length === 0)
+        return null;
+    return file.tokens[0].token;
+}
+/** Export the default file path so callers can reference it in logs/docs. */
+export { DEFAULT_TOKEN_FILE };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"consoleToken.js","sourceRoot":"","sources":["../../../src/web/console/consoleToken.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Console session token storage and verification (#1780).\n *\n * Manages the file at `~/.dollhouse/run/console-token.auth.json` which\n * holds the Bearer tokens that authenticate requests to the web console.\n * The file is created on first leader election and persists across\n * restarts — tokens only rotate when explicitly requested.\n *\n * The `.auth` filename suffix keeps this state isolated from any legacy\n * no-authentication DollhouseMCP installation running on the same\n * machine. The port, lock file, and token file all share the same\n * isolation strategy — see `src/config/env.ts` for the port, and\n * `LeaderElection.ts` for the lock file.\n *\n * Schema is forward-compatible with multi-device, multi-tenant, and\n * scope-restricted tokens for Phase 2+. Phase 1 uses a single \"console\"\n * kind token and stubs the scope/boundary checks.\n *\n * File format (version 1):\n * ```json\n * {\n *   \"version\": 1,\n *   \"tokens\": [\n *     {\n *       \"id\": \"018e1a2b-...\",\n *       \"name\": \"Kermit on mick-MacBook-Pro\",\n *       \"kind\": \"console\",\n *       \"token\": \"<64-hex>\",\n *       \"scopes\": [\"admin\"],\n *       \"elementBoundaries\": null,\n *       \"tenant\": null,\n *       \"platform\": \"local\",\n *       \"labels\": {},\n *       \"createdAt\": \"2026-04-04T20:00:00.000Z\",\n *       \"lastUsedAt\": null,\n *       \"createdVia\": \"initial-setup\"\n *     }\n *   ],\n *   \"totp\": { \"enrolled\": false, \"secret\": null, \"backupCodes\": [] }\n * }\n * ```\n *\n * @since v2.1.0 — Issue #1780\n */\n\nimport { homedir, hostname, platform } from 'node:os';\nimport { join } from 'node:path';\nimport { mkdir, readFile, rename, writeFile, chmod, unlink, copyFile } from 'node:fs/promises';\nimport { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';\nimport { Secret, TOTP } from 'otpauth';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { logger } from '../../utils/logger.js';\n\n/** Directory for runtime state files — same as LeaderElection. */\nconst RUN_DIR = join(homedir(), '.dollhouse', 'run');\n\n/**\n * Default path to the authenticated console's token file.\n *\n * The `.auth` suffix isolates this from any legacy no-authentication\n * DollhouseMCP installation that may also be running on the same\n * machine. Legacy installs did not write a token file at all; the\n * authenticated console writes `console-token.auth.json`. Combined with\n * the port and lock-file separation, this gives the two generations of\n * the console fully independent state trees under `~/.dollhouse/run/`.\n *\n * Callers can override via `DOLLHOUSE_CONSOLE_TOKEN_FILE` in the env.\n */\nconst DEFAULT_TOKEN_FILE = join(RUN_DIR, 'console-token.auth.json');\n\n/** Current token file schema version. */\nconst TOKEN_FILE_VERSION = 1 as const;\n\n/** Token length in bytes (produces a 64-character hex string). */\nconst TOKEN_BYTES = 32;\n\n/** File mode for the token file — owner read/write only. */\nconst TOKEN_FILE_MODE = 0o600;\n\n/**\n * TOTP configuration — RFC 6238 defaults. These are compiled-in so the\n * otpauth URI is deterministic and compatible with every common authenticator\n * app (Google Authenticator, 1Password, Authy, Bitwarden, etc.).\n */\nconst TOTP_ISSUER = 'DollhouseMCP';\nconst TOTP_ALGORITHM = 'SHA1' as const;\nconst TOTP_DIGITS = 6;\nconst TOTP_PERIOD_SECONDS = 30;\nconst TOTP_SECRET_SIZE_BYTES = 20; // 160 bits — the RFC 6238 recommendation\n/**\n * ±2 time step tolerance (±60s drift) → 150 second total validity window.\n *\n * The naive choice would be `window: 1` (±30s, 90s total) which is the RFC\n * 6238 default and matches most web login flows where the user types a code\n * they just generated, with sub-second latency to the server. That doesn't\n * cover our real deployment profile:\n *\n * 1. **Async bridge flows** — DollhouseBridge over Zulip (or similar chat\n *    transports) can add 10-60 seconds of latency between the user typing\n *    the code and the MCP server verifying it. A code typed with a few\n *    seconds of lifetime remaining can slide out of the validation window\n *    before reaching the server.\n *\n * 2. **Clock drift** — containers, VMs, and phones with lazy NTP can\n *    disagree with the server by tens of seconds. ±30s gives zero margin\n *    against any drift at all.\n *\n * `window: 2` gives 5 valid codes out of 10^6 per attempt (vs. 3 with\n * window=1). Combined with the 10/min rate limiter and the always-on auth\n * gate, brute-force success probability remains below 5e-5 per minute —\n * well within the security envelope. `window: 3` (±90s, 210s total) is\n * defensible but reserved for future deployment pressure; easier to widen\n * later than to narrow later.\n *\n * Note: the window is anchored to the **server's verification clock**, not\n * the user's code-generation clock. When a user complains that a code they\n * \"just typed\" was rejected, the error message nudges them to submit codes\n * with plenty of step-lifetime remaining.\n */\nconst TOTP_VALIDATE_WINDOW = 2;\n\n/**\n * Error message for a failed TOTP code check. Includes a hint about the\n * common failure mode (code aged out in transit) so users on high-latency\n * channels know what to try differently on retry.\n */\nconst INVALID_TOTP_MESSAGE =\n  'Invalid TOTP code. When copying from an authenticator app, use a code ' +\n  'with plenty of lifetime remaining — codes can age out in transit on ' +\n  'slower channels (e.g. chat bridges). Wait for a fresh code if unsure.';\n/** Pending enrollments expire this long after begin() to limit in-memory secret lifetime. */\nconst TOTP_PENDING_TTL_MS = 10 * 60 * 1000; // 10 minutes\n/**\n * Hard cap on concurrent pending enrollments. An authenticated caller who\n * misbehaves could otherwise fill the in-memory Map with 10-minute-TTL\n * secrets. Realistic users need at most 1 pending enrollment at a time;\n * 10 is generous headroom for retry-during-enrollment scenarios.\n *\n * When the cap is hit, `beginTotpEnrollment` throws `TOO_MANY_PENDING`\n * (mapped to HTTP 429). Rejecting loudly is preferred over silently\n * evicting someone else's legitimate pending entry.\n */\nconst MAX_PENDING_ENROLLMENTS = 10;\n\n/**\n * Grace window for old tokens after rotation — 15 seconds.\n *\n * After a rotation, the previous token value stays valid for this period to\n * cover in-flight requests from the rotating tab and any other local processes\n * that read the token file but haven't picked up the new value yet. All\n * consumers are loopback-only (127.0.0.1), so network latency is negligible\n * and 15s is generous.\n *\n * Grace entries are per-rotation and in-memory only — they are never persisted\n * to disk. A leader crash kills all grace entries, which is the safe failure\n * mode (callers re-auth with the new token from the file).\n */\nconst ROTATION_GRACE_MS = 15_000;\n\n/** Number of backup codes generated on enrollment. */\nconst BACKUP_CODE_COUNT = 10;\n/** Characters per backup code — Crockford base32-ish, no ambiguous chars. */\nconst BACKUP_CODE_LENGTH = 8;\n/**\n * Backup code alphabet — Crockford base32 (32 chars, excludes I/L/O/U).\n * 5 bits per char × 8 chars = 40 bits per code, plenty for one-shot use.\n */\nconst BACKUP_CODE_ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';\n\n/**\n * Strict format for console tokens — 64 lowercase hex characters.\n * Used as a defense-in-depth check in verify(): even if the caller forgot\n * to sanitize the presented value, we reject anything that isn't a legitimate\n * 256-bit hex token before reaching the constant-time comparison.\n * DMCP-SEC-004 mitigation.\n */\nconst TOKEN_FORMAT = /^[0-9a-f]{64}$/;\n\n/**\n * Element visibility boundary — Phase 3 enterprise feature.\n * Phase 1 always stores `null`; the field exists so the schema is stable.\n */\nexport interface ElementBoundary {\n  allowCategories?: string[];\n  denyCategories?: string[];\n  allowTypes?: string[];\n  denyTypes?: string[];\n}\n\n/**\n * A single token entry in the console token file.\n *\n * Enterprise-ready fields (`scopes`, `elementBoundaries`, `tenant`, `platform`,\n * `labels`) are present from Phase 1 but not enforced — the middleware treats\n * every valid token as admin-scoped, single-tenant, all-elements for now.\n * Phase 2+ flips enforcement on without requiring a schema migration.\n */\nexport interface ConsoleTokenEntry {\n  /** Stable unique identifier for this token (UUID v4). */\n  id: string;\n  /** Human-readable name shown in the Security tab. */\n  name: string;\n  /** What kind of client this token is for. */\n  kind: 'console' | 'device' | 'automation';\n  /** The secret Bearer value. 64 hex chars (256 bits of entropy). */\n  token: string;\n  /** Scopes granted to this token. Phase 1 = always `[\"admin\"]`. */\n  scopes: string[];\n  /** Element visibility restriction. Phase 1 = always `null`. */\n  elementBoundaries: ElementBoundary | null;\n  /** Tenant identifier for multi-tenant deployments. Phase 1 = always `null`. */\n  tenant: string | null;\n  /** Where this token is used. Phase 1 = always `\"local\"`. */\n  platform: string;\n  /** Opaque metadata for enterprise tooling. Phase 1 = always `{}`. */\n  labels: Record<string, string>;\n  /** ISO timestamp of token creation. */\n  createdAt: string;\n  /** ISO timestamp of most recent use, or null if never used. */\n  lastUsedAt: string | null;\n  /** How this token was created — \"initial-setup\", \"pairing\", \"rotation\", etc. */\n  createdVia: string;\n}\n\n/**\n * TOTP enrollment state.\n *\n * Populated by Phase 2 (#1794). The `secret` field holds the base32-encoded\n * RFC 6238 secret in plaintext — the surrounding file is 0600, which matches\n * standard file-based TOTP storage practice (SSH keys, age identity files,\n * 1Password vault backups). Encrypting the secret at rest with an OS keychain\n * is a future enhancement.\n *\n * Backup codes are stored as **sha256 hex hashes**, never plaintext. The\n * plaintext codes are shown to the user exactly once at enrollment confirm\n * time. Each backup code is single-use: consuming one removes its hash from\n * this array.\n *\n * `enrolledAt` is optional for backward compatibility with Phase 1 files,\n * which were written with only `{enrolled, secret, backupCodes}`.\n */\nexport interface TotpState {\n  enrolled: boolean;\n  secret: string | null;\n  backupCodes: string[];\n  enrolledAt?: string | null;\n}\n\n/**\n * Public-safe view of TOTP state — never leaks secret material.\n * Returned from the status endpoint and from store methods that need to\n * report enrollment state to callers.\n */\nexport interface TotpStatus {\n  enrolled: boolean;\n  enrolledAt: string | null;\n  backupCodesRemaining: number;\n}\n\n/**\n * Result of `beginTotpEnrollment` — the caller needs all of these to show a\n * QR code and manual-entry fallback in the UI. None of this is persisted;\n * the pending state only lives in-memory until confirmed.\n */\nexport interface TotpEnrollmentBegin {\n  pendingId: string;\n  /** Base32-encoded TOTP secret for manual entry (grouped display is caller's job). */\n  secret: string;\n  /** Full `otpauth://` URI for authenticator apps to import. */\n  otpauthUri: string;\n  /** Timestamp (ms since epoch) when this pending enrollment expires. */\n  expiresAt: number;\n}\n\n/**\n * Result of `confirmTotpEnrollment` — the plaintext backup codes are\n * returned to the caller exactly once, at this point, and then only their\n * hashes are retained. The caller must display them to the user immediately\n * and never log them.\n */\nexport interface TotpEnrollmentConfirm {\n  backupCodes: string[];\n  enrolledAt: string;\n}\n\n/**\n * Result of `rotatePrimary` — returned to the caller so they can update\n * the browser token in-place and display the grace-window deadline.\n */\nexport interface RotationResult {\n  /** The new 64-hex token value. The caller must treat this as a secret. */\n  token: string;\n  /** ISO timestamp of the rotation. */\n  rotatedAt: string;\n  /** ms-since-epoch deadline after which the old token stops verifying. */\n  graceUntil: number;\n}\n\n/** In-memory grace entry for a recently-rotated token. */\ninterface GraceEntry {\n  buf: Buffer;\n  expiresAt: number;\n}\n\n/** Internal pending-enrollment state — secret held in memory only. */\ninterface PendingEnrollment {\n  secret: string;\n  label: string;\n  expiresAt: number;\n}\n\n/**\n * Typed error for TOTP store operations. Carries a machine-readable\n * `code` field so the HTTP layer can map failures to consistent response\n * codes without parsing free-form error messages. Callers (CLI, UI) can\n * branch on `code` instead of the human-readable `message`.\n */\nexport class TotpError extends Error {\n  constructor(message: string, public readonly code: TotpErrorCode) {\n    super(message);\n    this.name = 'TotpError';\n  }\n}\n\n/** Discriminated set of TOTP failure reasons surfaced by the store. */\nexport type TotpErrorCode =\n  | 'ALREADY_ENROLLED'\n  | 'NOT_ENROLLED'\n  | 'PENDING_NOT_FOUND'\n  | 'INVALID_TOTP_CODE'\n  | 'STORE_NOT_INITIALIZED'\n  | 'TOO_MANY_PENDING'\n  | 'TOTP_REQUIRED';\n\n/**\n * The full on-disk token file structure.\n */\nexport interface ConsoleTokenFile {\n  version: typeof TOKEN_FILE_VERSION;\n  tokens: ConsoleTokenEntry[];\n  totp: TotpState;\n}\n\n/**\n * A safe-to-log view of a token entry — the secret `token` field is\n * replaced with a masked preview so it never appears in logs or API responses.\n */\nexport interface MaskedTokenEntry extends Omit<ConsoleTokenEntry, 'token'> {\n  tokenPreview: string;\n}\n\n/**\n * Generate a cryptographically random token.\n * Returns 64 hex characters (256 bits of entropy).\n */\nfunction generateTokenValue(): string {\n  return randomBytes(TOKEN_BYTES).toString('hex');\n}\n\n/**\n * Mask a token for display — shows first 8 chars only.\n */\nfunction maskToken(token: string): string {\n  if (token.length <= 8) return '••••••••';\n  return `${token.slice(0, 8)}${'•'.repeat(Math.min(56, token.length - 8))}`;\n}\n\n/**\n * Build a human-readable default name from a puppet name and the machine hostname.\n * Example: \"Kermit on mick-MacBook-Pro\".\n *\n * The puppet name is passed in rather than imported to avoid a circular dependency\n * with SessionNames (which only generates per-process names).\n */\nfunction defaultTokenName(puppetName: string): string {\n  const host = hostname() || 'localhost';\n  return `${puppetName} on ${host}`;\n}\n\n/**\n * Generate a batch of random backup codes. Each code is `BACKUP_CODE_LENGTH`\n * characters drawn uniformly from `BACKUP_CODE_ALPHABET` (Crockford base32,\n * 32 characters, 5 bits per char). Uses rejection sampling against 256-bit\n * random bytes to avoid modulo bias.\n */\nfunction generateBackupCodes(): string[] {\n  // 32-char alphabet divides 256 evenly (256 / 32 = 8), so the simple\n  // mod-32 mapping has no bias. Generate one byte per character.\n  const codes: string[] = [];\n  for (let i = 0; i < BACKUP_CODE_COUNT; i++) {\n    const bytes = randomBytes(BACKUP_CODE_LENGTH);\n    let code = '';\n    for (let j = 0; j < BACKUP_CODE_LENGTH; j++) {\n      code += BACKUP_CODE_ALPHABET[bytes[j] & 0x1f];\n    }\n    codes.push(code);\n  }\n  return codes;\n}\n\n/**\n * Hash a backup code for storage. sha256 hex is plenty — these codes are\n * high-entropy (40 bits) and we only need to detect a tamper, not resist\n * password-cracking on a leaked hash.\n */\nfunction hashBackupCode(code: string): string {\n  return createHash('sha256').update(code, 'utf8').digest('hex');\n}\n\n/**\n * Normalize a user-entered backup code before hashing: uppercase, strip\n * whitespace, strip dashes (users often type codes in groups like\n * \"XXXX-XXXX\"). Returns the canonical form that matches what we stored.\n */\nfunction normalizeBackupCode(raw: string): string {\n  return raw.replaceAll(/[\\s-]/g, '').toUpperCase();\n}\n\n/**\n * Build the full otpauth:// URI for a given secret and display label.\n * The label is URI-encoded by `otpauth` internally via URIComponent.\n */\nfunction buildTotpUri(secret: Secret, label: string): string {\n  const totp = new TOTP({\n    issuer: TOTP_ISSUER,\n    label,\n    algorithm: TOTP_ALGORITHM,\n    digits: TOTP_DIGITS,\n    period: TOTP_PERIOD_SECONDS,\n    secret,\n  });\n  return totp.toString();\n}\n\n/**\n * Validate a single token entry object. Returns true if the entry has all\n * required fields with the correct types. Extracted from validateTokenFile\n * to keep the top-level validator's cognitive complexity manageable.\n */\nfunction isValidTokenEntry(raw: unknown): boolean {\n  if (!raw || typeof raw !== 'object') return false;\n  const e = raw as Record<string, unknown>;\n  return (\n    typeof e.id === 'string' && e.id.length > 0 &&\n    typeof e.name === 'string' &&\n    typeof e.token === 'string' && e.token.length > 0 &&\n    typeof e.kind === 'string' &&\n    Array.isArray(e.scopes) &&\n    typeof e.createdAt === 'string'\n  );\n}\n\n/**\n * Validate that a parsed JSON object conforms to the expected token file schema.\n * Returns a typed ConsoleTokenFile or null if invalid.\n *\n * Strict validation — an unrecognized version or missing required fields\n * causes the file to be treated as corrupt so a fresh one can be written.\n */\nfunction validateTokenFile(raw: unknown): ConsoleTokenFile | null {\n  if (!raw || typeof raw !== 'object') return null;\n  const obj = raw as Record<string, unknown>;\n\n  if (obj.version !== TOKEN_FILE_VERSION) return null;\n  if (!Array.isArray(obj.tokens)) return null;\n  if (!obj.totp || typeof obj.totp !== 'object') return null;\n  if (!obj.tokens.every(isValidTokenEntry)) return null;\n\n  return raw as ConsoleTokenFile;\n}\n\n/**\n * Stateful store that owns the console token file and verifies presented tokens.\n *\n * Designed to live on the leader process. Followers should not construct this —\n * they read the file directly via `readTokenFileRaw()` for their own HTTP calls.\n */\nexport class ConsoleTokenStore {\n  private readonly filePath: string;\n  private data: ConsoleTokenFile | null = null;\n  /**\n   * Pre-converted Buffer cache keyed by entry id. Populated whenever `this.data`\n   * is assigned (load, create, future rotation). Verify() reuses the stored\n   * buffers so the hot path doesn't re-allocate per-token on every request.\n   * Negligible win with 1 token today; meaningful with Phase 2 multi-token\n   * lookups. Not serialized — buffers are never written to disk.\n   */\n  private readonly tokenBuffers = new Map<string, Buffer>();\n  /**\n   * In-memory pending TOTP enrollments, keyed by opaque pendingId. Nothing\n   * lives on disk until confirmTotpEnrollment() succeeds, which limits the\n   * window in which a half-completed enrollment leaks a secret via file read.\n   * Entries expire after TOTP_PENDING_TTL_MS (#1794).\n   */\n  private readonly pendingEnrollments = new Map<string, PendingEnrollment>();\n  /**\n   * In-memory grace buffer for recently-rotated tokens (#1795). After a\n   * rotation, the old token value is stashed here with a per-rotation expiry\n   * so in-flight requests that were sent before the rotation response arrived\n   * still authenticate. Entries are per-rotation (concurrent rotations each\n   * get their own grace slot) and never persisted to disk.\n   */\n  private readonly graceEntries: GraceEntry[] = [];\n\n  constructor(filePath: string = DEFAULT_TOKEN_FILE) {\n    this.filePath = filePath;\n  }\n\n  /**\n   * Rebuild the token buffer cache after a data load, create, or mutation.\n   * Keeps the hot verify() path allocation-free for the stored side.\n   */\n  private rebuildTokenBuffers(): void {\n    this.tokenBuffers.clear();\n    if (!this.data) return;\n    for (const entry of this.data.tokens) {\n      this.tokenBuffers.set(entry.id, Buffer.from(entry.token, 'utf8'));\n    }\n  }\n\n  /**\n   * Read the existing token file, or create a new one with a single initial\n   * token if none exists. Idempotent — safe to call on every leader election.\n   *\n   * @param puppetName - A puppet name picked by the caller (e.g. from SessionNames)\n   *                     used to build the default display name on first run.\n   * @returns The primary (first) token entry — convenient for server startup\n   *          to inject into HTML and stamp on followers.\n   */\n  async ensureInitialized(puppetName: string): Promise<ConsoleTokenEntry> {\n    const readResult = await this.readWithStatus();\n    if (readResult.status === 'ok' && readResult.data.tokens.length > 0) {\n      this.data = readResult.data;\n      this.rebuildTokenBuffers();\n      logger.debug('[ConsoleToken] Loaded existing token file', {\n        path: this.filePath,\n        count: readResult.data.tokens.length,\n      });\n      return readResult.data.tokens[0];\n    }\n\n    // If the file existed but was corrupt, back it up before overwriting.\n    // Users may have hand-edited the file with custom names/labels — don't\n    // destroy their data silently. A timestamped copy lets them recover.\n    if (readResult.status === 'corrupt') {\n      await this.backupCorruptFile();\n    }\n\n    // Create a fresh file with one initial token\n    const now = new Date().toISOString();\n    const initial: ConsoleTokenEntry = {\n      id: randomUUID(),\n      name: defaultTokenName(puppetName),\n      kind: 'console',\n      token: generateTokenValue(),\n      scopes: ['admin'],\n      elementBoundaries: null,\n      tenant: null,\n      platform: 'local',\n      labels: {},\n      createdAt: now,\n      lastUsedAt: null,\n      createdVia: 'initial-setup',\n    };\n\n    const file: ConsoleTokenFile = {\n      version: TOKEN_FILE_VERSION,\n      tokens: [initial],\n      totp: { enrolled: false, secret: null, backupCodes: [], enrolledAt: null },\n    };\n\n    await this.write(file);\n    this.data = file;\n    this.rebuildTokenBuffers();\n    logger.info('[ConsoleToken] Created new token file', {\n      path: this.filePath,\n      id: initial.id,\n      name: initial.name,\n    });\n    return initial;\n  }\n\n  /**\n   * Verify a presented Bearer token against the stored entries.\n   * Uses timing-safe comparison to prevent side-channel attacks.\n   *\n   * Updates `lastUsedAt` on the matched entry (in memory only; disk write\n   * is debounced to avoid disk thrash on every request — Phase 2 feature).\n   *\n   * @returns The matching entry, or null if no match.\n   */\n  verify(presented: string): ConsoleTokenEntry | null {\n    if (!this.data || !presented) return null;\n\n    // DMCP-SEC-004: Normalize the presented token to NFC and validate the\n    // strict hex format before any comparison. This blocks Unicode abuse\n    // (homographs, zero-width, bidi overrides) from reaching timingSafeEqual.\n    // Defense-in-depth — the middleware already sanitizes, but verify() is a\n    // public API that any future caller could invoke directly.\n    const normalized = UnicodeValidator.normalize(presented).normalizedContent;\n    if (!TOKEN_FORMAT.test(normalized)) return null;\n\n    // Only the presented side is allocated per-request; stored buffers are\n    // pre-converted in the tokenBuffers cache so the hot loop is allocation-free.\n    const presentedBuf = Buffer.from(normalized, 'utf8');\n\n    for (const entry of this.data.tokens) {\n      const storedBuf = this.tokenBuffers.get(entry.id);\n      if (!storedBuf || storedBuf.length !== presentedBuf.length) continue;\n      if (timingSafeEqual(presentedBuf, storedBuf)) {\n        entry.lastUsedAt = new Date().toISOString();\n        return entry;\n      }\n    }\n\n    // Check grace buffer — recently-rotated tokens that haven't expired yet.\n    // Returns the primary entry on match so the caller gets the same admin\n    // shape; the grace window just extends the authentication period.\n    this.sweepExpiredGraceEntries();\n    for (const grace of this.graceEntries) {\n      if (grace.buf.length === presentedBuf.length && timingSafeEqual(presentedBuf, grace.buf)) {\n        // Touch the primary entry — the request is still \"using\" this token slot.\n        if (this.data.tokens.length > 0) {\n          this.data.tokens[0].lastUsedAt = new Date().toISOString();\n        }\n        return this.data.tokens[0] ?? null;\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Get the primary token value for injection into HTML or forwarder config.\n   * Returns the first entry's token string, or null if uninitialized.\n   */\n  getPrimaryTokenValue(): string | null {\n    if (!this.data || this.data.tokens.length === 0) return null;\n    return this.data.tokens[0].token;\n  }\n\n  /**\n   * Return all tokens with the secret value masked — safe to serialize for\n   * the Security tab UI or `GET /api/console/token/info` responses.\n   */\n  listMasked(): MaskedTokenEntry[] {\n    if (!this.data) return [];\n    return this.data.tokens.map(({ token, ...rest }) => ({\n      ...rest,\n      tokenPreview: maskToken(token),\n    }));\n  }\n\n  /**\n   * Get the path to the token file on disk.\n   */\n  getFilePath(): string {\n    return this.filePath;\n  }\n\n  // --------------------------------------------------------------------\n  // TOTP — Phase 2 (#1794)\n  // --------------------------------------------------------------------\n\n  /**\n   * Returns a safe-to-serialize view of TOTP enrollment state. Never leaks\n   * the secret or any backup code material.\n   */\n  getTotpStatus(): TotpStatus {\n    const totp = this.data?.totp;\n    if (!totp?.enrolled) {\n      return { enrolled: false, enrolledAt: null, backupCodesRemaining: 0 };\n    }\n    return {\n      enrolled: true,\n      enrolledAt: totp.enrolledAt ?? null,\n      backupCodesRemaining: totp.backupCodes.length,\n    };\n  }\n\n  /** Convenience: true if the user has a confirmed TOTP secret. */\n  isTotpEnrolled(): boolean {\n    return Boolean(this.data?.totp?.enrolled && this.data.totp.secret);\n  }\n\n  /**\n   * Begin a TOTP enrollment. Generates a fresh secret, holds it in the\n   * in-memory pending map, and returns the data the UI needs to render a\n   * QR code and manual-entry fallback. Nothing is persisted until\n   * `confirmTotpEnrollment` succeeds.\n   *\n   * Callers may call this multiple times; each call produces a new pendingId\n   * and secret. Old pending entries expire after TOTP_PENDING_TTL_MS.\n   *\n   * @throws Error if TOTP is already enrolled — callers must disable first.\n   */\n  beginTotpEnrollment(label?: string): TotpEnrollmentBegin {\n    if (this.isTotpEnrolled()) {\n      throw new TotpError(\n        'TOTP is already enrolled — disable existing enrollment before enrolling again',\n        'ALREADY_ENROLLED',\n      );\n    }\n    this.sweepExpiredEnrollments();\n    // Reject if we're already at the per-process cap on concurrent pendings.\n    // Sweep ran above, so any slot still held is a live, unexpired enrollment\n    // belonging to somebody else — evicting it could silently kill their flow.\n    if (this.pendingEnrollments.size >= MAX_PENDING_ENROLLMENTS) {\n      throw new TotpError(\n        `Too many pending enrollments (max ${MAX_PENDING_ENROLLMENTS}); wait for existing pendings to expire or be confirmed`,\n        'TOO_MANY_PENDING',\n      );\n    }\n\n    // Derive a display label from the primary token name if the caller\n    // didn't provide one. Authenticator apps show \"<Issuer>:<label>\", so\n    // including the token name gives multi-device users a way to tell\n    // enrollments apart.\n    const displayLabel = label\n      ?? this.data?.tokens[0]?.name\n      ?? 'console';\n\n    const secret = new Secret({ size: TOTP_SECRET_SIZE_BYTES });\n    const pendingId = randomUUID();\n    const expiresAt = Date.now() + TOTP_PENDING_TTL_MS;\n    this.pendingEnrollments.set(pendingId, {\n      secret: secret.base32,\n      label: displayLabel,\n      expiresAt,\n    });\n\n    logger.debug('[ConsoleToken] TOTP enrollment begun', { pendingId, label: displayLabel });\n\n    return {\n      pendingId,\n      secret: secret.base32,\n      otpauthUri: buildTotpUri(secret, displayLabel),\n      expiresAt,\n    };\n  }\n\n  /**\n   * Confirm a pending TOTP enrollment. Verifies the code against the pending\n   * secret; on success, generates 10 plaintext backup codes, hashes them for\n   * storage, and persists the enrollment. Returns the plaintext backup codes\n   * exactly once — the caller is responsible for showing them to the user\n   * and then discarding them.\n   *\n   * Wrong codes do NOT consume or invalidate the pending enrollment — the\n   * user can retry until it expires. This matches user expectations for\n   * \"oops, typed the wrong code\" and limits the damage from a fat-fingered\n   * first attempt.\n   *\n   * @throws Error if pendingId is unknown, expired, or code invalid.\n   */\n  async confirmTotpEnrollment(pendingId: string, code: string): Promise<TotpEnrollmentConfirm> {\n    if (!this.data) {\n      throw new TotpError('Token store not initialized', 'STORE_NOT_INITIALIZED');\n    }\n    this.sweepExpiredEnrollments();\n    const pending = this.pendingEnrollments.get(pendingId);\n    if (!pending) {\n      throw new TotpError('Pending enrollment not found or expired', 'PENDING_NOT_FOUND');\n    }\n\n    // Verify the presented code against the pending secret. `validate` returns\n    // the time-step delta (a number, possibly 0) on match, or null on mismatch.\n    const totp = new TOTP({\n      issuer: TOTP_ISSUER,\n      label: pending.label,\n      algorithm: TOTP_ALGORITHM,\n      digits: TOTP_DIGITS,\n      period: TOTP_PERIOD_SECONDS,\n      secret: Secret.fromBase32(pending.secret),\n    });\n    const sanitized = code.replaceAll(/\\s/g, '');\n    const delta = totp.validate({ token: sanitized, window: TOTP_VALIDATE_WINDOW });\n    if (delta === null) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'TOTP_VERIFICATION_FAILED',\n        severity: 'MEDIUM',\n        source: 'ConsoleTokenStore.confirmTotpEnrollment',\n        details: 'Pending TOTP enrollment failed code verification',\n      });\n      throw new TotpError(INVALID_TOTP_MESSAGE, 'INVALID_TOTP_CODE');\n    }\n\n    // Code is valid — commit enrollment.\n    const plaintextCodes = generateBackupCodes();\n    const hashedCodes = plaintextCodes.map(hashBackupCode);\n    const enrolledAt = new Date().toISOString();\n\n    this.data.totp = {\n      enrolled: true,\n      secret: pending.secret,\n      backupCodes: hashedCodes,\n      enrolledAt,\n    };\n    await this.write(this.data);\n    this.pendingEnrollments.delete(pendingId);\n\n    logger.info('[ConsoleToken] TOTP enrollment confirmed', {\n      enrolledAt,\n      backupCodes: hashedCodes.length,\n    });\n    SecurityMonitor.logSecurityEvent({\n      type: 'TOTP_ENROLLED',\n      severity: 'MEDIUM',\n      source: 'ConsoleTokenStore.confirmTotpEnrollment',\n      details: 'Console TOTP second factor enrolled',\n      additionalData: { enrolledAt, backupCodes: hashedCodes.length },\n    });\n\n    return { backupCodes: plaintextCodes, enrolledAt };\n  }\n\n  /**\n   * Verify a user-presented code. Accepts either a live TOTP code or a\n   * single-use backup code. On successful backup-code match, the consumed\n   * code's hash is removed from storage and the file is re-written.\n   *\n   * Returns a discriminated result so the caller can distinguish \"consumed\n   * a backup code\" (which the UI should surface with a warning about\n   * remaining count) from \"valid TOTP code\" (normal case). Returns\n   * `{ ok: false }` on any failure — the caller should not retry within\n   * the same request lifecycle.\n   */\n  async verifyTotp(code: string): Promise<{ ok: true; method: 'totp' | 'backup'; backupCodesRemaining: number } | { ok: false }> {\n    if (!this.data?.totp?.enrolled || !this.data.totp.secret) {\n      return { ok: false };\n    }\n    const sanitized = code.replaceAll(/\\s/g, '');\n    if (!sanitized) return { ok: false };\n\n    // Try live TOTP first — fast path, no disk write.\n    const totp = new TOTP({\n      issuer: TOTP_ISSUER,\n      label: this.data.tokens[0]?.name ?? 'console',\n      algorithm: TOTP_ALGORITHM,\n      digits: TOTP_DIGITS,\n      period: TOTP_PERIOD_SECONDS,\n      secret: Secret.fromBase32(this.data.totp.secret),\n    });\n    if (totp.validate({ token: sanitized, window: TOTP_VALIDATE_WINDOW }) !== null) {\n      return { ok: true, method: 'totp', backupCodesRemaining: this.data.totp.backupCodes.length };\n    }\n\n    // Fall back to backup code — normalize, hash, constant-time search.\n    const normalizedInput = normalizeBackupCode(sanitized);\n    const inputHash = hashBackupCode(normalizedInput);\n    const inputHashBuf = Buffer.from(inputHash, 'hex');\n    let matchIndex = -1;\n    for (let i = 0; i < this.data.totp.backupCodes.length; i++) {\n      const storedBuf = Buffer.from(this.data.totp.backupCodes[i], 'hex');\n      if (storedBuf.length === inputHashBuf.length && timingSafeEqual(inputHashBuf, storedBuf)) {\n        matchIndex = i;\n        break;\n      }\n    }\n    if (matchIndex === -1) {\n      // Both TOTP and backup code paths exhausted without a match. Emit a\n      // single audit event so the security monitor can alert on aggregate\n      // failure rates (SecurityMonitor dedups the same type+source within\n      // a 60s window, so rapid-fire attacks are collapsed into one entry).\n      SecurityMonitor.logSecurityEvent({\n        type: 'TOTP_VERIFICATION_FAILED',\n        severity: 'MEDIUM',\n        source: 'ConsoleTokenStore.verifyTotp',\n        details: 'Presented TOTP code matched neither the live secret nor any backup code',\n      });\n      return { ok: false };\n    }\n\n    // Consume the matched backup code — remove from storage and persist.\n    this.data.totp.backupCodes.splice(matchIndex, 1);\n    await this.write(this.data);\n    logger.info('[ConsoleToken] Backup code consumed', {\n      remaining: this.data.totp.backupCodes.length,\n    });\n    SecurityMonitor.logSecurityEvent({\n      type: 'TOTP_BACKUP_CODE_CONSUMED',\n      severity: 'MEDIUM',\n      source: 'ConsoleTokenStore.verifyTotp',\n      details: 'TOTP backup code consumed for console authentication',\n      additionalData: { remaining: this.data.totp.backupCodes.length },\n    });\n    return { ok: true, method: 'backup', backupCodesRemaining: this.data.totp.backupCodes.length };\n  }\n\n  /**\n   * Disable TOTP. Requires a valid code (TOTP or backup) as confirmation so\n   * an attacker who momentarily has access to a live session can't silently\n   * strip the second factor.\n   *\n   * @throws Error if not enrolled or code invalid.\n   */\n  async disableTotp(code: string): Promise<void> {\n    if (!this.data) {\n      throw new TotpError('Token store not initialized', 'STORE_NOT_INITIALIZED');\n    }\n    if (!this.isTotpEnrolled()) {\n      throw new TotpError('TOTP is not currently enrolled', 'NOT_ENROLLED');\n    }\n    const result = await this.verifyTotp(code);\n    if (!result.ok) {\n      throw new TotpError(INVALID_TOTP_MESSAGE, 'INVALID_TOTP_CODE');\n    }\n    this.data.totp = {\n      enrolled: false,\n      secret: null,\n      backupCodes: [],\n      enrolledAt: null,\n    };\n    await this.write(this.data);\n    logger.info('[ConsoleToken] TOTP disabled');\n    SecurityMonitor.logSecurityEvent({\n      type: 'TOTP_DISABLED',\n      severity: 'HIGH',\n      source: 'ConsoleTokenStore.disableTotp',\n      details: 'Console TOTP second factor disabled — single-factor auth restored',\n    });\n  }\n\n  /** Remove any pending enrollments whose TTL has passed. */\n  private sweepExpiredEnrollments(): void {\n    const now = Date.now();\n    for (const [id, pending] of this.pendingEnrollments) {\n      if (pending.expiresAt <= now) {\n        this.pendingEnrollments.delete(id);\n      }\n    }\n  }\n\n  // --------------------------------------------------------------------\n  // end TOTP\n  // --------------------------------------------------------------------\n\n  // --------------------------------------------------------------------\n  // Token rotation — #1795\n  // --------------------------------------------------------------------\n\n  /**\n   * Rotate the primary console token. Requires TOTP confirmation (Pattern B).\n   *\n   * Flow:\n   * 1. Verify the confirmation code via `verifyTotp()` (live TOTP or backup code).\n   * 2. Stash the old token value in the in-memory grace buffer so in-flight\n   *    requests from the rotating tab (and any other local process that read\n   *    the file before the rotation) still authenticate for ROTATION_GRACE_MS.\n   * 3. Generate a new 32-byte token, mutate the primary entry in place, write\n   *    the file atomically, and rebuild the buffer cache.\n   * 4. Return the new token inline so the caller can update `DollhouseAuth.token`\n   *    without a page reload.\n   *\n   * Pattern A (OS dialog fallback for users without TOTP) is deferred — the\n   * caller should gate the UI so the rotate action is only available when\n   * TOTP is enrolled.\n   *\n   * @throws TotpError STORE_NOT_INITIALIZED — store never loaded\n   * @throws TotpError TOTP_REQUIRED — TOTP not enrolled, rotation requires second-factor confirmation\n   * @throws TotpError INVALID_TOTP_CODE — wrong code\n   */\n  async rotatePrimary(confirmationCode: string): Promise<RotationResult> {\n    if (!this.data) {\n      throw new TotpError('Token store not initialized', 'STORE_NOT_INITIALIZED');\n    }\n    if (!this.isTotpEnrolled()) {\n      throw new TotpError(\n        'Token rotation requires TOTP enrollment — enroll a second factor before rotating',\n        'TOTP_REQUIRED',\n      );\n    }\n\n    // Step 1: verify the confirmation code.\n    const verification = await this.verifyTotp(confirmationCode);\n    if (!verification.ok) {\n      throw new TotpError(INVALID_TOTP_MESSAGE, 'INVALID_TOTP_CODE');\n    }\n\n    // Step 2: stash the old token in the grace buffer.\n    const primary = this.data.tokens[0];\n    const graceDeadline = Date.now() + ROTATION_GRACE_MS;\n    this.sweepExpiredGraceEntries();\n    this.graceEntries.push({\n      buf: Buffer.from(primary.token, 'utf8'),\n      expiresAt: graceDeadline,\n    });\n\n    // Step 3: generate a new token, mutate the primary entry, persist.\n    const rotatedAt = new Date().toISOString();\n    primary.token = generateTokenValue();\n    primary.createdAt = rotatedAt;\n    primary.lastUsedAt = null;\n    primary.createdVia = 'rotation';\n\n    await this.write(this.data);\n    this.rebuildTokenBuffers();\n\n    logger.info('[ConsoleToken] Primary token rotated', {\n      id: primary.id,\n      rotatedAt,\n      graceMs: ROTATION_GRACE_MS,\n    });\n    SecurityMonitor.logSecurityEvent({\n      type: 'CONSOLE_TOKEN_ROTATED',\n      severity: 'HIGH',\n      source: 'ConsoleTokenStore.rotatePrimary',\n      details: 'Console primary token rotated via TOTP confirmation',\n      additionalData: {\n        tokenId: primary.id,\n        rotatedAt,\n        graceMs: ROTATION_GRACE_MS,\n        confirmationMethod: verification.method,\n      },\n    });\n\n    return {\n      token: primary.token,\n      rotatedAt,\n      graceUntil: graceDeadline,\n    };\n  }\n\n  /** Remove expired grace entries so they stop matching in verify(). */\n  private sweepExpiredGraceEntries(): void {\n    const now = Date.now();\n    let i = 0;\n    while (i < this.graceEntries.length) {\n      if (this.graceEntries[i].expiresAt <= now) {\n        this.graceEntries.splice(i, 1);\n      } else {\n        i++;\n      }\n    }\n  }\n\n  // --------------------------------------------------------------------\n  // end rotation\n  // --------------------------------------------------------------------\n\n  /**\n   * Read the token file and distinguish missing from corrupt.\n   *\n   * Returning a tagged union lets `ensureInitialized()` back up corrupt files\n   * before overwriting them — users who hand-edited their tokens with custom\n   * names or labels deserve a recovery path instead of a silent destroy.\n   */\n  private async readWithStatus(): Promise<\n    | { status: 'ok'; data: ConsoleTokenFile }\n    | { status: 'missing' }\n    | { status: 'corrupt'; reason: string }\n  > {\n    let content: string;\n    try {\n      content = await readFile(this.filePath, 'utf8');\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === 'ENOENT') return { status: 'missing' };\n      return { status: 'corrupt', reason: err instanceof Error ? err.message : String(err) };\n    }\n    try {\n      const parsed = JSON.parse(content);\n      const validated = validateTokenFile(parsed);\n      if (!validated) return { status: 'corrupt', reason: 'schema validation failed' };\n      return { status: 'ok', data: validated };\n    } catch (err) {\n      return { status: 'corrupt', reason: err instanceof Error ? err.message : String(err) };\n    }\n  }\n\n  /**\n   * Copy the current (presumed corrupt) token file to a timestamped backup\n   * alongside it so the user can recover hand-edited data after an accidental\n   * syntax error. Best-effort — failure to back up does not block creating\n   * a fresh file, since the primary goal is keeping the console usable.\n   */\n  private async backupCorruptFile(): Promise<void> {\n    const timestamp = new Date().toISOString().replaceAll(/[:.]/g, '-');\n    const backupPath = `${this.filePath}.corrupt-${timestamp}`;\n    try {\n      await copyFile(this.filePath, backupPath);\n      logger.warn(`[ConsoleToken] Corrupt token file backed up to ${backupPath} — a fresh token will be created`);\n    } catch (err) {\n      logger.warn('[ConsoleToken] Could not back up corrupt token file, will overwrite in place', {\n        error: err instanceof Error ? err.message : String(err),\n      });\n    }\n  }\n\n  /**\n   * Atomically write the token file with owner-only permissions.\n   * Uses temp+rename to avoid partial writes on crash.\n   *\n   * On Windows, `chmod(0o600)` is effectively a no-op because the file\n   * system uses ACLs instead of POSIX modes. We log a one-time warning so\n   * users on Windows know the token file does not have OS-enforced access\n   * control and can decide whether to use additional tooling (icacls, NTFS\n   * permissions, or a different storage location).\n   */\n  private async write(file: ConsoleTokenFile): Promise<void> {\n    await mkdir(RUN_DIR, { recursive: true });\n    const tmpFile = `${this.filePath}.${process.pid}.tmp`;\n    try {\n      await writeFile(tmpFile, JSON.stringify(file, null, 2), 'utf8');\n      await chmod(tmpFile, TOKEN_FILE_MODE);\n      await rename(tmpFile, this.filePath);\n      this.warnIfWindowsPermissions();\n    } catch (err) {\n      try { await unlink(tmpFile); } catch { /* ignore */ }\n      throw err;\n    }\n  }\n\n  /** One-shot flag so the Windows permissions warning is logged at most once. */\n  private windowsWarningLogged = false;\n\n  private warnIfWindowsPermissions(): void {\n    if (this.windowsWarningLogged) return;\n    if (platform() !== 'win32') return;\n    this.windowsWarningLogged = true;\n    logger.warn(\n      `[ConsoleToken] Token file at ${this.filePath} has no OS-enforced access control on Windows ` +\n      `(chmod 0o600 is a no-op on this platform). Any process running as the same user can read the file. ` +\n      `Consider using NTFS ACLs via 'icacls' for stronger isolation in multi-user environments.`,\n    );\n  }\n}\n\n/**\n * Read the raw token file from disk without constructing a store.\n * Intended for follower processes that need the primary token to attach\n * to their ingest POSTs. Returns null if the file does not exist or is invalid.\n *\n * @param filePath - Optional override for the token file location\n */\nexport async function readTokenFileRaw(filePath: string = DEFAULT_TOKEN_FILE): Promise<ConsoleTokenFile | null> {\n  try {\n    const content = await readFile(filePath, 'utf8');\n    return validateTokenFile(JSON.parse(content));\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Get the primary token value from the token file on disk.\n * Convenience helper for followers and external consumers.\n */\nexport async function getPrimaryTokenFromFile(filePath: string = DEFAULT_TOKEN_FILE): Promise<string | null> {\n  const file = await readTokenFileRaw(filePath);\n  if (!file || file.tokens.length === 0) return null;\n  return file.tokens[0].token;\n}\n\n/** Export the default file path so callers can reference it in logs/docs. */\nexport { DEFAULT_TOKEN_FILE };\n"]}