@dollhousemcp/mcp-server 2.0.10 → 2.0.11

package/dist/web/middleware/authMiddleware.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Express middleware for console Bearer token authentication (#1780).
+ *
+ * Checks the `Authorization: Bearer <token>` header on requests to protected
+ * endpoints, with a `?token=<token>` query parameter fallback for SSE streams
+ * (EventSource cannot set custom headers).
+ *
+ * Behavior is gated on the `DOLLHOUSE_WEB_AUTH_ENABLED` env var. When the flag
+ * is false (the default during Phase 1 rollout) the middleware is a no-op —
+ * requests pass through unconditionally. When true, every protected request
+ * must carry a valid token or receive a 401.
+ *
+ * Phase 1 design notes:
+ * - Every valid token is treated as admin-scoped. Scope enforcement is a
+ *   stubbed hook (`authorizeScope`) that always returns true. Phase 2 swaps
+ *   in real scope checks without touching any route handler.
+ * - Element boundaries and tenant filtering are similarly stubbed for Phase 3.
+ * - The middleware attaches the matched token entry to `res.locals.tokenEntry`
+ *   so downstream handlers can inspect it (audit logs, scope decisions, etc.).
+ *
+ * @since v2.1.0 — Issue #1780
+ */
+import type { RequestHandler } from 'express';
+import type { ConsoleTokenStore } from '../console/consoleToken.js';
+/**
+ * Options for the auth middleware factory.
+ */
+export interface AuthMiddlewareOptions {
+    /** The token store holding valid tokens. */
+    store: ConsoleTokenStore;
+    /** Whether auth is enforced. When false, middleware is a no-op. */
+    enabled: boolean;
+    /**
+     * Path prefixes that are never protected. A request whose URL path starts
+     * with any of these strings will skip auth and be passed through to the
+     * next handler. Used to exempt health checks, version info, client detection,
+     * and similar public metadata endpoints.
+     *
+     * Paths are compared against `req.path` (the route-relative path), so include
+     * the full pathname starting with `/` — e.g. `/api/health`, `/api/setup/version`.
+     */
+    publicPathPrefixes?: string[];
+    /** Optional label for log messages (e.g. "api" or "sse"). */
+    label?: string;
+}
+/**
+ * Create the core authentication middleware.
+ *
+ * The returned handler enforces Bearer token auth on every request it sees.
+ * Mount it with `app.use(createAuthMiddleware(...))` before protected routers,
+ * or attach it to individual routes that need protection.
+ *
+ * When `enabled: false`, the handler immediately calls `next()` — allowing
+ * the infrastructure to land with the default-off feature flag without
+ * breaking existing traffic.
+ *
+ * Phase 3 hardening (tracked in #1789): Add 401 rate limiting to prevent
+ * DoS from floods of bad-token requests. Brute-forcing a 256-bit token is
+ * infeasible, but an attacker flooding /api with wrong tokens could saturate
+ * the verify path. A sliding-window limiter keyed on the requesting IP is
+ * the right shape.
+ */
+export declare function createAuthMiddleware(options: AuthMiddlewareOptions): RequestHandler;
+//# sourceMappingURL=authMiddleware.d.ts.map

package/dist/web/middleware/authMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authMiddleware.d.ts","sourceRoot":"","sources":["../../../src/web/middleware/authMiddleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAmC,cAAc,EAAE,MAAM,SAAS,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAqB,MAAM,4BAA4B,CAAC;AAsEvF;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,4CAA4C;IAC5C,KAAK,EAAE,iBAAiB,CAAC;IACzB,mEAAmE;IACnE,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;;;;OAQG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CAyCnF"}

package/dist/web/middleware/authMiddleware.js

@@ -0,0 +1,174 @@
+/**
+ * Express middleware for console Bearer token authentication (#1780).
+ *
+ * Checks the `Authorization: Bearer <token>` header on requests to protected
+ * endpoints, with a `?token=<token>` query parameter fallback for SSE streams
+ * (EventSource cannot set custom headers).
+ *
+ * Behavior is gated on the `DOLLHOUSE_WEB_AUTH_ENABLED` env var. When the flag
+ * is false (the default during Phase 1 rollout) the middleware is a no-op —
+ * requests pass through unconditionally. When true, every protected request
+ * must carry a valid token or receive a 401.
+ *
+ * Phase 1 design notes:
+ * - Every valid token is treated as admin-scoped. Scope enforcement is a
+ *   stubbed hook (`authorizeScope`) that always returns true. Phase 2 swaps
+ *   in real scope checks without touching any route handler.
+ * - Element boundaries and tenant filtering are similarly stubbed for Phase 3.
+ * - The middleware attaches the matched token entry to `res.locals.tokenEntry`
+ *   so downstream handlers can inspect it (audit logs, scope decisions, etc.).
+ *
+ * @since v2.1.0 — Issue #1780
+ */
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { logger } from '../../utils/logger.js';
+/** Query parameter name used as a fallback for SSE streams. */
+const TOKEN_QUERY_PARAM = 'token';
+/** Header name we look at for Bearer tokens. */
+const AUTH_HEADER = 'authorization';
+/** Prefix expected on the Authorization header value. */
+const BEARER_PREFIX = 'Bearer ';
+/**
+ * Strict format for console tokens — 64 lowercase hex characters (256 bits).
+ * Any presented token that does not match this pattern is rejected before it
+ * reaches the constant-time comparison. This blocks any non-ASCII Unicode
+ * payload (homographs, zero-width, bidi overrides, etc.) from ever touching
+ * the verify path. DMCP-SEC-004 mitigation.
+ */
+const TOKEN_FORMAT = /^[0-9a-f]{64}$/;
+/**
+ * Sanitize a raw token string pulled from a request.
+ *
+ * - Normalizes to NFC via UnicodeValidator (DMCP-SEC-004)
+ * - Validates against the strict hex format
+ * - Returns the cleaned value, or null if anything looks wrong
+ *
+ * Any failure here results in a 401 at the call site. Legitimate tokens are
+ * 64-char lowercase hex, so normalization and format validation are effectively
+ * no-ops for valid input and hard rejections for anything malicious.
+ */
+function sanitizePresentedToken(raw) {
+    if (!raw)
+        return null;
+    const normalized = UnicodeValidator.normalize(raw).normalizedContent;
+    if (!TOKEN_FORMAT.test(normalized))
+        return null;
+    return normalized;
+}
+/**
+ * Extract a Bearer token from a request.
+ * Checks Authorization header first, then query parameter.
+ * Applies Unicode normalization and strict format validation before returning.
+ * Returns the sanitized token string, or null if none was found or the value
+ * failed validation.
+ */
+function extractToken(req) {
+    // Preferred: Authorization: Bearer <token>
+    const header = req.headers[AUTH_HEADER];
+    if (typeof header === 'string' && header.startsWith(BEARER_PREFIX)) {
+        const value = header.slice(BEARER_PREFIX.length).trim();
+        if (value) {
+            const sanitized = sanitizePresentedToken(value);
+            if (sanitized)
+                return sanitized;
+        }
+    }
+    // Fallback for EventSource: ?token=<token>
+    const q = req.query[TOKEN_QUERY_PARAM];
+    if (typeof q === 'string' && q.length > 0) {
+        return sanitizePresentedToken(q);
+    }
+    if (Array.isArray(q) && q.length > 0 && typeof q[0] === 'string') {
+        return sanitizePresentedToken(q[0]);
+    }
+    return null;
+}
+/**
+ * Create the core authentication middleware.
+ *
+ * The returned handler enforces Bearer token auth on every request it sees.
+ * Mount it with `app.use(createAuthMiddleware(...))` before protected routers,
+ * or attach it to individual routes that need protection.
+ *
+ * When `enabled: false`, the handler immediately calls `next()` — allowing
+ * the infrastructure to land with the default-off feature flag without
+ * breaking existing traffic.
+ *
+ * Phase 3 hardening (tracked in #1789): Add 401 rate limiting to prevent
+ * DoS from floods of bad-token requests. Brute-forcing a 256-bit token is
+ * infeasible, but an attacker flooding /api with wrong tokens could saturate
+ * the verify path. A sliding-window limiter keyed on the requesting IP is
+ * the right shape.
+ */
+export function createAuthMiddleware(options) {
+    const { store, enabled, label = 'console' } = options;
+    const publicPaths = options.publicPathPrefixes ?? [];
+    return (req, res, next) => {
+        if (!enabled) {
+            return next();
+        }
+        // Public path allowlist — skip auth for whitelisted prefixes.
+        // Use originalUrl.pathname so we match regardless of mount point.
+        const pathToCheck = req.originalUrl.split('?')[0];
+        for (const prefix of publicPaths) {
+            if (pathToCheck === prefix || pathToCheck.startsWith(prefix + '/')) {
+                return next();
+            }
+        }
+        const presented = extractToken(req);
+        if (!presented) {
+            return respondUnauthorized(res, 'missing_token', label, store, 0);
+        }
+        const entry = store.verify(presented);
+        if (!entry) {
+            // Log presented-length only — never the presented value itself.
+            // Distinguishes "token missing" from "token wrong length" from
+            // "length matches but content differs" when troubleshooting.
+            return respondUnauthorized(res, 'invalid_token', label, store, presented.length);
+        }
+        // Stubbed authorization hook — Phase 2 flips real scope checks on here.
+        if (!authorizeScope(entry, req)) {
+            return respondForbidden(res, 'scope_denied', label, entry);
+        }
+        // Stash the matched entry for downstream handlers and log success at debug.
+        res.locals.tokenEntry = entry;
+        logger.debug(`[Auth:${label}] verified token id=${entry.id} name="${entry.name}" route=${req.method} ${req.originalUrl.split('?')[0]}`);
+        return next();
+    };
+}
+/**
+ * Scope authorization hook.
+ *
+ * Phase 1: every valid token is treated as admin — returns true unconditionally.
+ * Phase 2: this function will check `entry.scopes` against the route's required
+ * scopes (which can be attached via `res.locals.requiredScope` or a route
+ * metadata system).
+ */
+function authorizeScope(_entry, _req) {
+    return true;
+}
+/**
+ * Respond with 401 Unauthorized and a helpful hint about where to find the token.
+ * Includes presented-token length at debug level for troubleshooting — never the value.
+ */
+function respondUnauthorized(res, reason, label, store, presentedLength) {
+    logger.debug(`[Auth:${label}] 401 ${reason} presentedLength=${presentedLength}`);
+    res.status(401).json({
+        error: 'Authentication required',
+        reason,
+        hint: `Token file: ${store.getFilePath()}. Send 'Authorization: Bearer <token>' header, or append ?token=<token> for SSE streams.`,
+    });
+}
+/**
+ * Respond with 403 Forbidden — token was valid but scope did not permit this route.
+ * Phase 1 never reaches here because `authorizeScope` always returns true, but
+ * the code path exists so Phase 2 can wire it up without changing the middleware shape.
+ */
+function respondForbidden(res, reason, label, entry) {
+    logger.debug(`[Auth:${label}] 403 ${reason}`, { tokenId: entry.id, scopes: entry.scopes });
+    res.status(403).json({
+        error: 'Token scope does not permit this action',
+        reason,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authMiddleware.js","sourceRoot":"","sources":["../../../src/web/middleware/authMiddleware.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Express middleware for console Bearer token authentication (#1780).\n *\n * Checks the `Authorization: Bearer <token>` header on requests to protected\n * endpoints, with a `?token=<token>` query parameter fallback for SSE streams\n * (EventSource cannot set custom headers).\n *\n * Behavior is gated on the `DOLLHOUSE_WEB_AUTH_ENABLED` env var. When the flag\n * is false (the default during Phase 1 rollout) the middleware is a no-op —\n * requests pass through unconditionally. When true, every protected request\n * must carry a valid token or receive a 401.\n *\n * Phase 1 design notes:\n * - Every valid token is treated as admin-scoped. Scope enforcement is a\n *   stubbed hook (`authorizeScope`) that always returns true. Phase 2 swaps\n *   in real scope checks without touching any route handler.\n * - Element boundaries and tenant filtering are similarly stubbed for Phase 3.\n * - The middleware attaches the matched token entry to `res.locals.tokenEntry`\n *   so downstream handlers can inspect it (audit logs, scope decisions, etc.).\n *\n * @since v2.1.0 — Issue #1780\n */\n\nimport type { Request, Response, NextFunction, RequestHandler } from 'express';\nimport type { ConsoleTokenStore, ConsoleTokenEntry } from '../console/consoleToken.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { logger } from '../../utils/logger.js';\n\n/** Query parameter name used as a fallback for SSE streams. */\nconst TOKEN_QUERY_PARAM = 'token';\n\n/** Header name we look at for Bearer tokens. */\nconst AUTH_HEADER = 'authorization';\n\n/** Prefix expected on the Authorization header value. */\nconst BEARER_PREFIX = 'Bearer ';\n\n/**\n * Strict format for console tokens — 64 lowercase hex characters (256 bits).\n * Any presented token that does not match this pattern is rejected before it\n * reaches the constant-time comparison. This blocks any non-ASCII Unicode\n * payload (homographs, zero-width, bidi overrides, etc.) from ever touching\n * the verify path. DMCP-SEC-004 mitigation.\n */\nconst TOKEN_FORMAT = /^[0-9a-f]{64}$/;\n\n/**\n * Sanitize a raw token string pulled from a request.\n *\n * - Normalizes to NFC via UnicodeValidator (DMCP-SEC-004)\n * - Validates against the strict hex format\n * - Returns the cleaned value, or null if anything looks wrong\n *\n * Any failure here results in a 401 at the call site. Legitimate tokens are\n * 64-char lowercase hex, so normalization and format validation are effectively\n * no-ops for valid input and hard rejections for anything malicious.\n */\nfunction sanitizePresentedToken(raw: string): string | null {\n  if (!raw) return null;\n  const normalized = UnicodeValidator.normalize(raw).normalizedContent;\n  if (!TOKEN_FORMAT.test(normalized)) return null;\n  return normalized;\n}\n\n/**\n * Extract a Bearer token from a request.\n * Checks Authorization header first, then query parameter.\n * Applies Unicode normalization and strict format validation before returning.\n * Returns the sanitized token string, or null if none was found or the value\n * failed validation.\n */\nfunction extractToken(req: Request): string | null {\n  // Preferred: Authorization: Bearer <token>\n  const header = req.headers[AUTH_HEADER];\n  if (typeof header === 'string' && header.startsWith(BEARER_PREFIX)) {\n    const value = header.slice(BEARER_PREFIX.length).trim();\n    if (value) {\n      const sanitized = sanitizePresentedToken(value);\n      if (sanitized) return sanitized;\n    }\n  }\n\n  // Fallback for EventSource: ?token=<token>\n  const q = req.query[TOKEN_QUERY_PARAM];\n  if (typeof q === 'string' && q.length > 0) {\n    return sanitizePresentedToken(q);\n  }\n  if (Array.isArray(q) && q.length > 0 && typeof q[0] === 'string') {\n    return sanitizePresentedToken(q[0]);\n  }\n\n  return null;\n}\n\n/**\n * Options for the auth middleware factory.\n */\nexport interface AuthMiddlewareOptions {\n  /** The token store holding valid tokens. */\n  store: ConsoleTokenStore;\n  /** Whether auth is enforced. When false, middleware is a no-op. */\n  enabled: boolean;\n  /**\n   * Path prefixes that are never protected. A request whose URL path starts\n   * with any of these strings will skip auth and be passed through to the\n   * next handler. Used to exempt health checks, version info, client detection,\n   * and similar public metadata endpoints.\n   *\n   * Paths are compared against `req.path` (the route-relative path), so include\n   * the full pathname starting with `/` — e.g. `/api/health`, `/api/setup/version`.\n   */\n  publicPathPrefixes?: string[];\n  /** Optional label for log messages (e.g. \"api\" or \"sse\"). */\n  label?: string;\n}\n\n/**\n * Create the core authentication middleware.\n *\n * The returned handler enforces Bearer token auth on every request it sees.\n * Mount it with `app.use(createAuthMiddleware(...))` before protected routers,\n * or attach it to individual routes that need protection.\n *\n * When `enabled: false`, the handler immediately calls `next()` — allowing\n * the infrastructure to land with the default-off feature flag without\n * breaking existing traffic.\n *\n * Phase 3 hardening (tracked in #1789): Add 401 rate limiting to prevent\n * DoS from floods of bad-token requests. Brute-forcing a 256-bit token is\n * infeasible, but an attacker flooding /api with wrong tokens could saturate\n * the verify path. A sliding-window limiter keyed on the requesting IP is\n * the right shape.\n */\nexport function createAuthMiddleware(options: AuthMiddlewareOptions): RequestHandler {\n  const { store, enabled, label = 'console' } = options;\n  const publicPaths = options.publicPathPrefixes ?? [];\n\n  return (req: Request, res: Response, next: NextFunction) => {\n    if (!enabled) {\n      return next();\n    }\n\n    // Public path allowlist — skip auth for whitelisted prefixes.\n    // Use originalUrl.pathname so we match regardless of mount point.\n    const pathToCheck = req.originalUrl.split('?')[0];\n    for (const prefix of publicPaths) {\n      if (pathToCheck === prefix || pathToCheck.startsWith(prefix + '/')) {\n        return next();\n      }\n    }\n\n    const presented = extractToken(req);\n    if (!presented) {\n      return respondUnauthorized(res, 'missing_token', label, store, 0);\n    }\n\n    const entry = store.verify(presented);\n    if (!entry) {\n      // Log presented-length only — never the presented value itself.\n      // Distinguishes \"token missing\" from \"token wrong length\" from\n      // \"length matches but content differs\" when troubleshooting.\n      return respondUnauthorized(res, 'invalid_token', label, store, presented.length);\n    }\n\n    // Stubbed authorization hook — Phase 2 flips real scope checks on here.\n    if (!authorizeScope(entry, req)) {\n      return respondForbidden(res, 'scope_denied', label, entry);\n    }\n\n    // Stash the matched entry for downstream handlers and log success at debug.\n    res.locals.tokenEntry = entry;\n    logger.debug(`[Auth:${label}] verified token id=${entry.id} name=\"${entry.name}\" route=${req.method} ${req.originalUrl.split('?')[0]}`);\n    return next();\n  };\n}\n\n/**\n * Scope authorization hook.\n *\n * Phase 1: every valid token is treated as admin — returns true unconditionally.\n * Phase 2: this function will check `entry.scopes` against the route's required\n * scopes (which can be attached via `res.locals.requiredScope` or a route\n * metadata system).\n */\nfunction authorizeScope(_entry: ConsoleTokenEntry, _req: Request): boolean {\n  return true;\n}\n\n/**\n * Respond with 401 Unauthorized and a helpful hint about where to find the token.\n * Includes presented-token length at debug level for troubleshooting — never the value.\n */\nfunction respondUnauthorized(\n  res: Response,\n  reason: 'missing_token' | 'invalid_token',\n  label: string,\n  store: ConsoleTokenStore,\n  presentedLength: number,\n): void {\n  logger.debug(`[Auth:${label}] 401 ${reason} presentedLength=${presentedLength}`);\n  res.status(401).json({\n    error: 'Authentication required',\n    reason,\n    hint: `Token file: ${store.getFilePath()}. Send 'Authorization: Bearer <token>' header, or append ?token=<token> for SSE streams.`,\n  });\n}\n\n/**\n * Respond with 403 Forbidden — token was valid but scope did not permit this route.\n * Phase 1 never reaches here because `authorizeScope` always returns true, but\n * the code path exists so Phase 2 can wire it up without changing the middleware shape.\n */\nfunction respondForbidden(\n  res: Response,\n  reason: string,\n  label: string,\n  entry: ConsoleTokenEntry,\n): void {\n  logger.debug(`[Auth:${label}] 403 ${reason}`, { tokenId: entry.id, scopes: entry.scopes });\n  res.status(403).json({\n    error: 'Token scope does not permit this action',\n    reason,\n  });\n}\n"]}

package/dist/web/routes/consoleRouteHelpers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared helpers for console auth route handlers (TOTP + token management).
+ *
+ * Extracted to eliminate duplication between totpRoutes.ts and tokenRoutes.ts.
+ * Both routers need the same error-mapping, structured-error-response, and
+ * body-field-extraction logic.
+ *
+ * @since v2.1.0 — Issue #1795
+ */
+import type { Response } from 'express';
+import type { TotpErrorCode } from '../console/consoleToken.js';
+/**
+ * Maps a store error code to the appropriate HTTP status.
+ * Centralized so all console auth endpoints return consistent status codes
+ * for the same failure class. The `satisfies never` exhaustiveness check
+ * ensures new TotpErrorCode values get mapped at compile time.
+ */
+export declare function httpStatusForStoreError(code: TotpErrorCode): number;
+/**
+ * Send a structured error response with both a human-readable message and
+ * a machine-readable code. Shape is stable so the CLI and Security tab UI
+ * can branch on `code` instead of string-matching the message.
+ */
+export declare function sendStoreError(res: Response, status: number, code: string, message: string): void;
+/**
+ * Safely extract a string field from an unknown request body and NFC-normalize
+ * it (DMCP-SEC-004). Returns null if the body is not an object or the field
+ * is missing / not a string. Normalization blocks homograph, bidi, and
+ * zero-width abuse before the value reaches downstream parsers (TOTP codes,
+ * otpauth URI labels, pending-id lookups).
+ */
+export declare function getNormalizedStringField(body: unknown, field: string): string | null;
+//# sourceMappingURL=consoleRouteHelpers.d.ts.map

package/dist/web/routes/consoleRouteHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleRouteHelpers.d.ts","sourceRoot":"","sources":["../../../src/web/routes/consoleRouteHelpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAGhE;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAmBnE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,IAAI,CAEN;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKpF"}

package/dist/web/routes/consoleRouteHelpers.js

@@ -0,0 +1,60 @@
+/**
+ * Shared helpers for console auth route handlers (TOTP + token management).
+ *
+ * Extracted to eliminate duplication between totpRoutes.ts and tokenRoutes.ts.
+ * Both routers need the same error-mapping, structured-error-response, and
+ * body-field-extraction logic.
+ *
+ * @since v2.1.0 — Issue #1795
+ */
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+/**
+ * Maps a store error code to the appropriate HTTP status.
+ * Centralized so all console auth endpoints return consistent status codes
+ * for the same failure class. The `satisfies never` exhaustiveness check
+ * ensures new TotpErrorCode values get mapped at compile time.
+ */
+export function httpStatusForStoreError(code) {
+    switch (code) {
+        case 'ALREADY_ENROLLED':
+            return 409;
+        case 'NOT_ENROLLED':
+        case 'PENDING_NOT_FOUND':
+        case 'INVALID_TOTP_CODE':
+            return 400;
+        case 'TOO_MANY_PENDING':
+            return 429;
+        case 'TOTP_REQUIRED':
+            return 403;
+        case 'STORE_NOT_INITIALIZED':
+            return 503;
+        default: {
+            code;
+            return 400;
+        }
+    }
+}
+/**
+ * Send a structured error response with both a human-readable message and
+ * a machine-readable code. Shape is stable so the CLI and Security tab UI
+ * can branch on `code` instead of string-matching the message.
+ */
+export function sendStoreError(res, status, code, message) {
+    res.status(status).json({ error: message, code });
+}
+/**
+ * Safely extract a string field from an unknown request body and NFC-normalize
+ * it (DMCP-SEC-004). Returns null if the body is not an object or the field
+ * is missing / not a string. Normalization blocks homograph, bidi, and
+ * zero-width abuse before the value reaches downstream parsers (TOTP codes,
+ * otpauth URI labels, pending-id lookups).
+ */
+export function getNormalizedStringField(body, field) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const val = body[field];
+    if (typeof val !== 'string')
+        return null;
+    return UnicodeValidator.normalize(val).normalizedContent;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/web/routes/tokenRoutes.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Console token management HTTP routes — #1795.
+ *
+ * Provides:
+ * - POST /api/console/token/rotate — rotate the primary token with TOTP confirmation
+ *
+ * Security model:
+ * - All endpoints require a valid existing console token. Enforcement
+ *   happens via an always-on `createAuthMiddleware` instance mounted at the
+ *   top of this router, independent of `DOLLHOUSE_WEB_AUTH_ENABLED`.
+ * - Rotation additionally requires TOTP confirmation (Pattern B). Pattern A
+ *   (OS dialog fallback) is deferred to a follow-up issue.
+ * - A sliding-window rate limit throttles rotation attempts so a bad actor
+ *   with a live session can't brute-force TOTP codes by flooding rotations.
+ *
+ * @since v2.1.0 — Issue #1795
+ */
+import { Router } from 'express';
+import { type ConsoleTokenStore } from '../console/consoleToken.js';
+/**
+ * Options for the token routes factory.
+ */
+export interface TokenRoutesOptions {
+    store: ConsoleTokenStore;
+    /** Maximum rotation attempts per window. Default: 10. */
+    rateLimitMax?: number;
+    /** Rate limit window in milliseconds. Default: 60_000 (1 minute). */
+    rateLimitWindowMs?: number;
+}
+/**
+ * Build the Express router exposing token management endpoints. The returned
+ * router should be mounted at `/api/console/token`; the caller does not need
+ * to add additional auth middleware — this router enforces its own auth
+ * regardless of the global feature flag.
+ */
+export declare function createTokenRoutes(options: TokenRoutesOptions): Router;
+//# sourceMappingURL=tokenRoutes.d.ts.map

package/dist/web/routes/tokenRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenRoutes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/tokenRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,EAAa,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAiB/E;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,iBAAiB,CAAC;IACzB,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAyDrE"}

package/dist/web/routes/tokenRoutes.js

@@ -0,0 +1,95 @@
+/**
+ * Console token management HTTP routes — #1795.
+ *
+ * Provides:
+ * - POST /api/console/token/rotate — rotate the primary token with TOTP confirmation
+ *
+ * Security model:
+ * - All endpoints require a valid existing console token. Enforcement
+ *   happens via an always-on `createAuthMiddleware` instance mounted at the
+ *   top of this router, independent of `DOLLHOUSE_WEB_AUTH_ENABLED`.
+ * - Rotation additionally requires TOTP confirmation (Pattern B). Pattern A
+ *   (OS dialog fallback) is deferred to a follow-up issue.
+ * - A sliding-window rate limit throttles rotation attempts so a bad actor
+ *   with a live session can't brute-force TOTP codes by flooding rotations.
+ *
+ * @since v2.1.0 — Issue #1795
+ */
+import express, { Router } from 'express';
+import { TotpError } from '../console/consoleToken.js';
+import { createAuthMiddleware } from '../middleware/authMiddleware.js';
+import { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';
+import { httpStatusForStoreError, sendStoreError, getNormalizedStringField } from './consoleRouteHelpers.js';
+import { logger } from '../../utils/logger.js';
+/** JSON body size limit — rotation requests are tiny. */
+const BODY_LIMIT = '1kb';
+/**
+ * Rate limit for the rotation endpoint: 10 attempts per minute.
+ * Same rationale as the TOTP enrollment confirm limiter — brute-force
+ * success probability stays well below 5e-5/min.
+ */
+const DEFAULT_RATE_LIMIT_MAX = 10;
+const DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000;
+/**
+ * Build the Express router exposing token management endpoints. The returned
+ * router should be mounted at `/api/console/token`; the caller does not need
+ * to add additional auth middleware — this router enforces its own auth
+ * regardless of the global feature flag.
+ */
+export function createTokenRoutes(options) {
+    const { store } = options;
+    const router = Router();
+    const jsonParser = express.json({ limit: BODY_LIMIT, type: 'application/json' });
+    const rateLimitMax = options.rateLimitMax ?? DEFAULT_RATE_LIMIT_MAX;
+    const rateLimitWindowMs = options.rateLimitWindowMs ?? DEFAULT_RATE_LIMIT_WINDOW_MS;
+    const rotateLimiter = new SlidingWindowRateLimiter(rateLimitMax, rateLimitWindowMs);
+    // Always-on auth — same pattern as the TOTP router.
+    const auth = createAuthMiddleware({
+        store,
+        enabled: true,
+        label: 'token',
+    });
+    router.use(auth);
+    /** GET /info — token metadata + TOTP status for the Security tab UI (#1791). */
+    router.get('/info', (_req, res) => {
+        const masked = store.listMasked();
+        const totpStatus = store.getTotpStatus();
+        res.json({
+            tokens: masked,
+            totp: totpStatus,
+            filePath: store.getFilePath(),
+        });
+    });
+    /** POST /rotate — rotate the primary console token with TOTP confirmation. */
+    router.post('/rotate', jsonParser, async (req, res) => {
+        if (!rotateLimiter.tryAcquire()) {
+            sendStoreError(res, 429, 'RATE_LIMITED', 'Too many rotation attempts — slow down');
+            return;
+        }
+        const confirmationCode = getNormalizedStringField(req.body, 'confirmationCode');
+        if (!confirmationCode) {
+            sendStoreError(res, 400, 'MISSING_FIELDS', 'confirmationCode is required');
+            return;
+        }
+        try {
+            const result = await store.rotatePrimary(confirmationCode);
+            res.json({
+                token: result.token,
+                rotatedAt: result.rotatedAt,
+                graceUntil: result.graceUntil,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Rotation failed';
+            logger.debug(`[Token] rotate failed: ${message}`);
+            if (err instanceof TotpError) {
+                sendStoreError(res, httpStatusForStoreError(err.code), err.code, err.message);
+            }
+            else {
+                sendStoreError(res, 500, 'INTERNAL', message);
+            }
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenRoutes.js","sourceRoot":"","sources":["../../../src/web/routes/tokenRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,EAAE,SAAS,EAA0B,MAAM,4BAA4B,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAE,uBAAuB,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAC7G,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C,yDAAyD;AACzD,MAAM,UAAU,GAAG,KAAK,CAAC;AAEzB;;;;GAIG;AACH,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAClC,MAAM,4BAA4B,GAAG,MAAM,CAAC;AAa5C;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAA2B;IAC3D,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;IAC1B,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC;IACxB,MAAM,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC;IACjF,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,IAAI,sBAAsB,CAAC;IACpE,MAAM,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,IAAI,4BAA4B,CAAC;IACpF,MAAM,aAAa,GAAG,IAAI,wBAAwB,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC;IAEpF,oDAAoD;IACpD,MAAM,IAAI,GAAG,oBAAoB,CAAC;QAChC,KAAK;QACL,OAAO,EAAE,IAAI;QACb,KAAK,EAAE,OAAO;KACf,CAAC,CAAC;IACH,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAEjB,gFAAgF;IAChF,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,IAAa,EAAE,GAAa,EAAE,EAAE;QACnD,MAAM,MAAM,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;QAClC,MAAM,UAAU,GAAG,KAAK,CAAC,aAAa,EAAE,CAAC;QACzC,GAAG,CAAC,IAAI,CAAC;YACP,MAAM,EAAE,MAAM;YACd,IAAI,EAAE,UAAU;YAChB,QAAQ,EAAE,KAAK,CAAC,WAAW,EAAE;SAC9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,8EAA8E;IAC9E,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,GAAY,EAAE,GAAa,EAAE,EAAE;QACvE,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,EAAE,CAAC;YAChC,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,cAAc,EAAE,wCAAwC,CAAC,CAAC;YACnF,OAAO;QACT,CAAC;QACD,MAAM,gBAAgB,GAAG,wBAAwB,CAAC,GAAG,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;QAChF,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,gBAAgB,EAAE,8BAA8B,CAAC,CAAC;YAC3E,OAAO;QACT,CAAC;QACD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC;YAC3D,GAAG,CAAC,IAAI,CAAC;gBACP,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,UAAU,EAAE,MAAM,CAAC,UAAU;aAC9B,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,iBAAiB,CAAC;YACvE,MAAM,CAAC,KAAK,CAAC,0BAA0B,OAAO,EAAE,CAAC,CAAC;YAClD,IAAI,GAAG,YAAY,SAAS,EAAE,CAAC;gBAC7B,cAAc,CAAC,GAAG,EAAE,uBAAuB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YAChF,CAAC;iBAAM,CAAC;gBACN,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;YAChD,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * Console token management HTTP routes — #1795.\n *\n * Provides:\n * - POST /api/console/token/rotate — rotate the primary token with TOTP confirmation\n *\n * Security model:\n * - All endpoints require a valid existing console token. Enforcement\n *   happens via an always-on `createAuthMiddleware` instance mounted at the\n *   top of this router, independent of `DOLLHOUSE_WEB_AUTH_ENABLED`.\n * - Rotation additionally requires TOTP confirmation (Pattern B). Pattern A\n *   (OS dialog fallback) is deferred to a follow-up issue.\n * - A sliding-window rate limit throttles rotation attempts so a bad actor\n *   with a live session can't brute-force TOTP codes by flooding rotations.\n *\n * @since v2.1.0 — Issue #1795\n */\n\nimport express, { Router } from 'express';\nimport type { Request, Response } from 'express';\nimport { TotpError, type ConsoleTokenStore } from '../console/consoleToken.js';\nimport { createAuthMiddleware } from '../middleware/authMiddleware.js';\nimport { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';\nimport { httpStatusForStoreError, sendStoreError, getNormalizedStringField } from './consoleRouteHelpers.js';\nimport { logger } from '../../utils/logger.js';\n\n/** JSON body size limit — rotation requests are tiny. */\nconst BODY_LIMIT = '1kb';\n\n/**\n * Rate limit for the rotation endpoint: 10 attempts per minute.\n * Same rationale as the TOTP enrollment confirm limiter — brute-force\n * success probability stays well below 5e-5/min.\n */\nconst DEFAULT_RATE_LIMIT_MAX = 10;\nconst DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000;\n\n/**\n * Options for the token routes factory.\n */\nexport interface TokenRoutesOptions {\n  store: ConsoleTokenStore;\n  /** Maximum rotation attempts per window. Default: 10. */\n  rateLimitMax?: number;\n  /** Rate limit window in milliseconds. Default: 60_000 (1 minute). */\n  rateLimitWindowMs?: number;\n}\n\n/**\n * Build the Express router exposing token management endpoints. The returned\n * router should be mounted at `/api/console/token`; the caller does not need\n * to add additional auth middleware — this router enforces its own auth\n * regardless of the global feature flag.\n */\nexport function createTokenRoutes(options: TokenRoutesOptions): Router {\n  const { store } = options;\n  const router = Router();\n  const jsonParser = express.json({ limit: BODY_LIMIT, type: 'application/json' });\n  const rateLimitMax = options.rateLimitMax ?? DEFAULT_RATE_LIMIT_MAX;\n  const rateLimitWindowMs = options.rateLimitWindowMs ?? DEFAULT_RATE_LIMIT_WINDOW_MS;\n  const rotateLimiter = new SlidingWindowRateLimiter(rateLimitMax, rateLimitWindowMs);\n\n  // Always-on auth — same pattern as the TOTP router.\n  const auth = createAuthMiddleware({\n    store,\n    enabled: true,\n    label: 'token',\n  });\n  router.use(auth);\n\n  /** GET /info — token metadata + TOTP status for the Security tab UI (#1791). */\n  router.get('/info', (_req: Request, res: Response) => {\n    const masked = store.listMasked();\n    const totpStatus = store.getTotpStatus();\n    res.json({\n      tokens: masked,\n      totp: totpStatus,\n      filePath: store.getFilePath(),\n    });\n  });\n\n  /** POST /rotate — rotate the primary console token with TOTP confirmation. */\n  router.post('/rotate', jsonParser, async (req: Request, res: Response) => {\n    if (!rotateLimiter.tryAcquire()) {\n      sendStoreError(res, 429, 'RATE_LIMITED', 'Too many rotation attempts — slow down');\n      return;\n    }\n    const confirmationCode = getNormalizedStringField(req.body, 'confirmationCode');\n    if (!confirmationCode) {\n      sendStoreError(res, 400, 'MISSING_FIELDS', 'confirmationCode is required');\n      return;\n    }\n    try {\n      const result = await store.rotatePrimary(confirmationCode);\n      res.json({\n        token: result.token,\n        rotatedAt: result.rotatedAt,\n        graceUntil: result.graceUntil,\n      });\n    } catch (err) {\n      const message = err instanceof Error ? err.message : 'Rotation failed';\n      logger.debug(`[Token] rotate failed: ${message}`);\n      if (err instanceof TotpError) {\n        sendStoreError(res, httpStatusForStoreError(err.code), err.code, err.message);\n      } else {\n        sendStoreError(res, 500, 'INTERNAL', message);\n      }\n    }\n  });\n\n  return router;\n}\n"]}

package/dist/web/routes/totpRoutes.d.ts

@@ -0,0 +1,45 @@
+/**
+ * TOTP (authenticator) enrollment HTTP routes — Phase 2 of #1780 (#1794).
+ *
+ * Provides:
+ * - GET    /api/console/totp/status        — enrollment state (no secrets)
+ * - POST   /api/console/totp/enroll/begin  — generate secret, return QR + otpauth URI
+ * - POST   /api/console/totp/enroll/confirm — verify code, persist, return backup codes (once)
+ * - POST   /api/console/totp/disable       — verify code, clear enrollment
+ *
+ * Security model:
+ * - All endpoints require a valid existing console token. The caller must
+ *   prove they already hold the token before they can enroll a second
+ *   factor — otherwise an attacker with local port access could pre-enroll
+ *   their own authenticator and lock the legitimate user out.
+ * - Enforcement happens via an always-on `createAuthMiddleware` instance
+ *   mounted at the top of this router, independent of the global
+ *   DOLLHOUSE_WEB_AUTH_ENABLED flag.
+ * - Backup codes are returned in plaintext exactly once (confirm response)
+ *   and only their sha256 hashes are retained by the store.
+ * - A sliding-window rate limit throttles confirm/disable attempts on a
+ *   per-IP basis so a bad actor with a live session can't brute-force a
+ *   TOTP window by flooding requests.
+ *
+ * @since v2.1.0 — Issue #1794
+ */
+import { Router } from 'express';
+import { type ConsoleTokenStore } from '../console/consoleToken.js';
+/**
+ * Options for the TOTP routes factory.
+ */
+export interface TotpRoutesOptions {
+    store: ConsoleTokenStore;
+    /** Maximum code-verification attempts per window. Default: 10. */
+    rateLimitMax?: number;
+    /** Rate limit window in milliseconds. Default: 60_000 (1 minute). */
+    rateLimitWindowMs?: number;
+}
+/**
+ * Build the Express router exposing TOTP endpoints. The returned router
+ * should be mounted at `/api/console/totp`; the caller does not need to
+ * add additional auth middleware — this router enforces its own auth
+ * regardless of the global feature flag.
+ */
+export declare function createTotpRoutes(options: TotpRoutesOptions): Router;
+//# sourceMappingURL=totpRoutes.d.ts.map

package/dist/web/routes/totpRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"totpRoutes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/totpRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAG1C,OAAO,EAAa,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AA4C/E;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,iBAAiB,CAAC;IACzB,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAgHnE"}