@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
95 lines • 13.4 kB
JavaScript
/**
* 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":"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","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"]}