@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.
358 lines • 43.6 kB
JavaScript
/**
* Gatekeeper Session Management
*
* Manages per-connection session state for the Gatekeeper Policy Engine.
* Each MCP client connection gets a separate session with isolated state.
*
* CRITICAL: Session state is IN-MEMORY only.
* - Confirmations are NOT persisted to disk
* - Each Claude Code / Claude Desktop / etc. = separate session
* - No cross-session policy leakage
* - Crash = fresh session (security-first decision)
*/
import { randomUUID } from 'crypto';
import { env } from '../../config/env.js';
/**
* Gatekeeper Session Manager.
* Manages per-connection session state with isolated confirmation tracking.
*
* DESIGN NOTES:
* - Session ID is generated on MCP connection initialization
* - Tied to the specific transport/connection
* - NOT shared via filesystem (in-memory per server instance)
* - Each `claude` CLI invocation spawns separate MCP server process = separate session
*
* PROCESS ISOLATION:
* Each Claude Code session = separate node process (verified)
* MCP stdio transport = child process per client. No sharing possible.
*
* HTTP/HTTPS TRANSPORT CONSIDERATIONS (for future implementers):
* If implementing HTTP/HTTPS transport instead of stdio:
* - Session state must be tied to authenticated client identity (API key, token)
* - Multiple LLM clients could connect to a shared server (unlike stdio's 1:1)
* - Consider signed session tokens (JWT) for stateless deployments
* - Implement session expiration and renewal mechanisms
* - For load-balanced deployments, use Redis or similar for shared session state
*/
/** Default maximum number of CLI approval records before LRU eviction */
const DEFAULT_MAX_CLI_APPROVALS = env.DOLLHOUSE_CLI_APPROVAL_MAX;
/** Default TTL for CLI approval records (5 minutes) */
const DEFAULT_APPROVAL_TTL_MS = env.DOLLHOUSE_CLI_APPROVAL_TTL_MS;
/** Minimum TTL for CLI approval records (1 second) */
const MIN_APPROVAL_TTL_MS = 1_000;
/** Maximum TTL for CLI approval records (24 hours) */
const MAX_APPROVAL_TTL_MS = 86_400_000;
/** Throttle interval for expiry sweeps (10 seconds) */
const EXPIRY_SWEEP_INTERVAL_MS = 10_000;
export class GatekeeperSession {
state;
maxConfirmations;
maxCliApprovals;
lastExpirySweep = 0;
constructor(clientInfo, maxConfirmations = 100, maxCliApprovals = DEFAULT_MAX_CLI_APPROVALS) {
this.maxConfirmations = maxConfirmations;
this.maxCliApprovals = maxCliApprovals;
this.state = {
sessionId: randomUUID(),
clientInfo,
createdAt: new Date().toISOString(),
lastActivity: new Date().toISOString(),
confirmations: new Map(),
cliApprovals: new Map(),
cliSessionApprovals: new Map(),
permissionPromptActive: false,
};
}
/**
* Get the unique session identifier.
*/
get sessionId() {
return this.state.sessionId;
}
/**
* Get the client information.
*/
get clientInfo() {
return this.state.clientInfo;
}
/**
* Get the session creation timestamp.
*/
get createdAt() {
return this.state.createdAt;
}
/**
* Get the last activity timestamp.
*/
get lastActivity() {
return this.state.lastActivity;
}
/**
* Whether permission_prompt has been invoked at least once this session.
* Used for fail-safe detection (Issue #625 Phase 4).
*/
get isPermissionPromptActive() {
return this.state.permissionPromptActive;
}
/**
* Mark that permission_prompt has been invoked.
* Called on first invocation to track that the CLI client supports it.
*/
markPermissionPromptActive() {
this.state.permissionPromptActive = true;
}
/**
* Update the last activity timestamp.
*/
touch() {
this.state.lastActivity = new Date().toISOString();
}
/**
* Record a confirmation for an operation.
* Confirmations are scoped to this session only.
*
* @param operation - The operation being confirmed
* @param permissionLevel - The permission level being confirmed
* @param elementType - Optional element type scope
*/
recordConfirmation(operation, permissionLevel, elementType) {
this.touch();
// Enforce max confirmations (LRU eviction)
if (this.state.confirmations.size >= this.maxConfirmations) {
// Remove oldest confirmation
const oldestKey = this.state.confirmations.keys().next().value;
if (oldestKey) {
this.state.confirmations.delete(oldestKey);
}
}
const key = this.getConfirmationKey(operation, elementType);
this.state.confirmations.set(key, {
operation,
confirmedAt: new Date().toISOString(),
permissionLevel,
useCount: 0,
elementType,
});
}
/**
* Check if an operation has a valid session confirmation.
* For CONFIRM_SINGLE_USE, this invalidates the confirmation after checking.
*
* RACE CONDITION NOTE:
* The check-then-delete for CONFIRM_SINGLE_USE is safe because:
* 1. Node.js is single-threaded - no concurrent access to Map
* 2. MCP requests are processed sequentially per connection
* 3. Each session instance is tied to a single client connection
* If this code is ever used in a multi-threaded context or with shared
* state across processes, atomic operations would be required.
*
* @param operation - The operation to check
* @param elementType - Optional element type scope
* @returns The confirmation record if valid, undefined otherwise
*/
checkConfirmation(operation, elementType) {
this.touch();
const key = this.getConfirmationKey(operation, elementType);
let confirmation = this.state.confirmations.get(key);
// Fall back to unscoped confirmation when element-type-scoped key not found.
// A session-wide confirmation for "create_element" covers "create_element:skill" etc.
if (!confirmation && elementType) {
confirmation = this.state.confirmations.get(operation);
}
if (!confirmation) {
return undefined;
}
// Increment use count
confirmation.useCount++;
// For CONFIRM_SINGLE_USE, invalidate after first use
if (confirmation.permissionLevel === 'CONFIRM_SINGLE_USE') {
// Delete whichever key matched (scoped or unscoped)
if (this.state.confirmations.has(key)) {
this.state.confirmations.delete(key);
}
else {
this.state.confirmations.delete(operation);
}
}
return confirmation;
}
/**
* Check if an operation has a session confirmation WITHOUT consuming it.
* Use this to check status without affecting the confirmation state.
*
* @param operation - The operation to check
* @param elementType - Optional element type scope
* @returns The confirmation record if exists, undefined otherwise
*/
peekConfirmation(operation, elementType) {
const key = this.getConfirmationKey(operation, elementType);
return this.state.confirmations.get(key);
}
/**
* Revoke a confirmation for an operation.
*
* @param operation - The operation to revoke
* @param elementType - Optional element type scope
* @returns true if a confirmation was revoked
*/
revokeConfirmation(operation, elementType) {
this.touch();
const key = this.getConfirmationKey(operation, elementType);
return this.state.confirmations.delete(key);
}
/**
* Revoke all confirmations for this session.
* Useful when security-sensitive changes occur.
*/
revokeAllConfirmations() {
this.touch();
this.state.confirmations.clear();
}
/**
* Get all active confirmations for this session.
* Useful for debugging and audit logging.
*/
getActiveConfirmations() {
return Array.from(this.state.confirmations.values());
}
// ── CLI Approval Store (Issue #625 Phase 3) ────────────────────
/**
* Create a CLI approval request.
* Returns a unique request ID (format: cli-<UUIDv4>).
*/
createCliApprovalRequest(toolName, toolInput, riskLevel, riskScore, irreversible, denyReason, policySource, ttlMs) {
this.touch();
this.expireStaleApprovals(true); // Force sweep on write path to ensure capacity
// LRU eviction at max capacity
if (this.state.cliApprovals.size >= this.maxCliApprovals) {
const oldestKey = this.state.cliApprovals.keys().next().value;
if (oldestKey) {
this.state.cliApprovals.delete(oldestKey);
}
}
const requestId = `cli-${randomUUID()}`;
// Clamp ttlMs to valid bounds (1s-24h) if provided
const clampedTtl = ttlMs != null
? Math.max(MIN_APPROVAL_TTL_MS, Math.min(MAX_APPROVAL_TTL_MS, ttlMs))
: undefined;
const record = {
requestId,
toolName,
toolInput,
riskLevel,
riskScore,
irreversible,
requestedAt: new Date().toISOString(),
consumed: false,
scope: 'single',
denyReason,
policySource,
ttlMs: clampedTtl,
};
this.state.cliApprovals.set(requestId, record);
return requestId;
}
/**
* Approve a pending CLI approval request.
* Sets approvedAt, and promotes to session approvals if tool_session scope.
*
* @returns The approved record, or undefined if not found
*/
approveCliRequest(requestId, scope = 'single') {
this.touch();
const record = this.state.cliApprovals.get(requestId);
if (!record || record.approvedAt) {
return undefined;
}
record.approvedAt = new Date().toISOString();
record.scope = scope;
// Promote to session approvals if tool_session scope
if (scope === 'tool_session') {
this.state.cliSessionApprovals.set(record.toolName, record);
}
return record;
}
/**
* Check if a CLI tool call has a valid approval.
* Checks session approvals first (fast path), then individual approvals.
* Consumes single-scope approvals on use.
*
* @returns The matching approval record, or undefined
*/
checkCliApproval(toolName, _toolInput) {
this.touch();
this.expireStaleApprovals();
// Fast path: check session-scoped approvals by tool name
const sessionApproval = this.state.cliSessionApprovals.get(toolName);
if (sessionApproval) {
return sessionApproval;
}
// Check individual approvals
for (const [, record] of this.state.cliApprovals) {
if (record.toolName === toolName && record.approvedAt && !record.consumed) {
if (record.scope === 'single') {
record.consumed = true;
}
return record;
}
}
return undefined;
}
/**
* Get all pending (unapproved) CLI approval requests.
* Forces expiry sweep to ensure accurate user-facing results.
*/
getPendingCliApprovals() {
this.expireStaleApprovals(true);
const pending = [];
for (const [, record] of this.state.cliApprovals) {
if (!record.approvedAt) {
pending.push(record);
}
}
return pending;
}
/**
* Expire stale approval requests.
* Uses per-record ttlMs if set, otherwise DEFAULT_APPROVAL_TTL_MS (5 minutes).
*
* @param force - Skip throttle check (used by write paths that must ensure capacity)
*/
expireStaleApprovals(force = false) {
const now = Date.now();
if (!force && now - this.lastExpirySweep < EXPIRY_SWEEP_INTERVAL_MS)
return;
this.lastExpirySweep = now;
for (const [key, record] of this.state.cliApprovals) {
const ttl = record.ttlMs ?? DEFAULT_APPROVAL_TTL_MS;
const age = now - new Date(record.requestedAt).getTime();
// Evict stale pending requests AND consumed single-use approvals (#1782)
if (age > ttl && (!record.approvedAt || record.consumed)) {
this.state.cliApprovals.delete(key);
}
}
}
/**
* Get a summary of the session state.
* Safe to expose for debugging without revealing sensitive data.
*/
getSummary() {
return {
sessionId: this.state.sessionId,
clientInfo: this.state.clientInfo,
createdAt: this.state.createdAt,
lastActivity: this.state.lastActivity,
confirmationCount: this.state.confirmations.size,
cliApprovalCount: this.state.cliApprovals.size,
permissionPromptActive: this.state.permissionPromptActive,
};
}
/**
* Generate a unique key for confirmation lookups.
* Combines operation and optional element type.
*/
getConfirmationKey(operation, elementType) {
return elementType ? `${operation}:${elementType}` : operation;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GatekeeperSession.js","sourceRoot":"","sources":["../../../src/handlers/mcp-aql/GatekeeperSession.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Gatekeeper Session Management\n *\n * Manages per-connection session state for the Gatekeeper Policy Engine.\n * Each MCP client connection gets a separate session with isolated state.\n *\n * CRITICAL: Session state is IN-MEMORY only.\n * - Confirmations are NOT persisted to disk\n * - Each Claude Code / Claude Desktop / etc. = separate session\n * - No cross-session policy leakage\n * - Crash = fresh session (security-first decision)\n */\n\nimport { randomUUID } from 'crypto';\nimport type { ConfirmationRecord, PermissionLevel, CliApprovalRecord, CliApprovalScope } from './GatekeeperTypes.js';\nimport { env } from '../../config/env.js';\n\n/**\n * Client information from MCP capabilities.\n * Identifies which MCP client is making requests.\n */\nexport interface ClientInfo {\n  /** Client name (e.g., \"claude-code\", \"claude-desktop\") */\n  name: string;\n  /** Client version */\n  version: string;\n}\n\n/**\n * Session state for a single MCP connection.\n * Tracks confirmations and activity for this session only.\n */\nexport interface GatekeeperSessionState {\n  /** Unique session identifier */\n  sessionId: string;\n  /** Client information from MCP capabilities */\n  clientInfo?: ClientInfo;\n  /** When the session was created */\n  createdAt: string;\n  /** Last activity timestamp */\n  lastActivity: string;\n  /** Map of operation -> confirmation record */\n  confirmations: Map<string, ConfirmationRecord>;\n  /** Map of requestId -> CLI approval record (Issue #625 Phase 3) */\n  cliApprovals: Map<string, CliApprovalRecord>;\n  /** Map of toolName -> session-scoped CLI approval (Issue #625 Phase 3) */\n  cliSessionApprovals: Map<string, CliApprovalRecord>;\n  /** Whether permission_prompt has been called at least once this session (Issue #625 Phase 4) */\n  permissionPromptActive: boolean;\n}\n\n/**\n * Gatekeeper Session Manager.\n * Manages per-connection session state with isolated confirmation tracking.\n *\n * DESIGN NOTES:\n * - Session ID is generated on MCP connection initialization\n * - Tied to the specific transport/connection\n * - NOT shared via filesystem (in-memory per server instance)\n * - Each `claude` CLI invocation spawns separate MCP server process = separate session\n *\n * PROCESS ISOLATION:\n * Each Claude Code session = separate node process (verified)\n * MCP stdio transport = child process per client. No sharing possible.\n *\n * HTTP/HTTPS TRANSPORT CONSIDERATIONS (for future implementers):\n * If implementing HTTP/HTTPS transport instead of stdio:\n * - Session state must be tied to authenticated client identity (API key, token)\n * - Multiple LLM clients could connect to a shared server (unlike stdio's 1:1)\n * - Consider signed session tokens (JWT) for stateless deployments\n * - Implement session expiration and renewal mechanisms\n * - For load-balanced deployments, use Redis or similar for shared session state\n */\n/** Default maximum number of CLI approval records before LRU eviction */\nconst DEFAULT_MAX_CLI_APPROVALS = env.DOLLHOUSE_CLI_APPROVAL_MAX;\n\n/** Default TTL for CLI approval records (5 minutes) */\nconst DEFAULT_APPROVAL_TTL_MS = env.DOLLHOUSE_CLI_APPROVAL_TTL_MS;\n\n/** Minimum TTL for CLI approval records (1 second) */\nconst MIN_APPROVAL_TTL_MS = 1_000;\n\n/** Maximum TTL for CLI approval records (24 hours) */\nconst MAX_APPROVAL_TTL_MS = 86_400_000;\n\n/** Throttle interval for expiry sweeps (10 seconds) */\nconst EXPIRY_SWEEP_INTERVAL_MS = 10_000;\n\nexport class GatekeeperSession {\n  private readonly state: GatekeeperSessionState;\n  private readonly maxConfirmations: number;\n  private readonly maxCliApprovals: number;\n  private lastExpirySweep = 0;\n\n  constructor(clientInfo?: ClientInfo, maxConfirmations: number = 100, maxCliApprovals: number = DEFAULT_MAX_CLI_APPROVALS) {\n    this.maxConfirmations = maxConfirmations;\n    this.maxCliApprovals = maxCliApprovals;\n    this.state = {\n      sessionId: randomUUID(),\n      clientInfo,\n      createdAt: new Date().toISOString(),\n      lastActivity: new Date().toISOString(),\n      confirmations: new Map(),\n      cliApprovals: new Map(),\n      cliSessionApprovals: new Map(),\n      permissionPromptActive: false,\n    };\n  }\n\n  /**\n   * Get the unique session identifier.\n   */\n  get sessionId(): string {\n    return this.state.sessionId;\n  }\n\n  /**\n   * Get the client information.\n   */\n  get clientInfo(): ClientInfo | undefined {\n    return this.state.clientInfo;\n  }\n\n  /**\n   * Get the session creation timestamp.\n   */\n  get createdAt(): string {\n    return this.state.createdAt;\n  }\n\n  /**\n   * Get the last activity timestamp.\n   */\n  get lastActivity(): string {\n    return this.state.lastActivity;\n  }\n\n  /**\n   * Whether permission_prompt has been invoked at least once this session.\n   * Used for fail-safe detection (Issue #625 Phase 4).\n   */\n  get isPermissionPromptActive(): boolean {\n    return this.state.permissionPromptActive;\n  }\n\n  /**\n   * Mark that permission_prompt has been invoked.\n   * Called on first invocation to track that the CLI client supports it.\n   */\n  markPermissionPromptActive(): void {\n    this.state.permissionPromptActive = true;\n  }\n\n  /**\n   * Update the last activity timestamp.\n   */\n  touch(): void {\n    this.state.lastActivity = new Date().toISOString();\n  }\n\n  /**\n   * Record a confirmation for an operation.\n   * Confirmations are scoped to this session only.\n   *\n   * @param operation - The operation being confirmed\n   * @param permissionLevel - The permission level being confirmed\n   * @param elementType - Optional element type scope\n   */\n  recordConfirmation(\n    operation: string,\n    permissionLevel: PermissionLevel.CONFIRM_SESSION | PermissionLevel.CONFIRM_SINGLE_USE,\n    elementType?: string\n  ): void {\n    this.touch();\n\n    // Enforce max confirmations (LRU eviction)\n    if (this.state.confirmations.size >= this.maxConfirmations) {\n      // Remove oldest confirmation\n      const oldestKey = this.state.confirmations.keys().next().value;\n      if (oldestKey) {\n        this.state.confirmations.delete(oldestKey);\n      }\n    }\n\n    const key = this.getConfirmationKey(operation, elementType);\n    this.state.confirmations.set(key, {\n      operation,\n      confirmedAt: new Date().toISOString(),\n      permissionLevel,\n      useCount: 0,\n      elementType,\n    });\n  }\n\n  /**\n   * Check if an operation has a valid session confirmation.\n   * For CONFIRM_SINGLE_USE, this invalidates the confirmation after checking.\n   *\n   * RACE CONDITION NOTE:\n   * The check-then-delete for CONFIRM_SINGLE_USE is safe because:\n   * 1. Node.js is single-threaded - no concurrent access to Map\n   * 2. MCP requests are processed sequentially per connection\n   * 3. Each session instance is tied to a single client connection\n   * If this code is ever used in a multi-threaded context or with shared\n   * state across processes, atomic operations would be required.\n   *\n   * @param operation - The operation to check\n   * @param elementType - Optional element type scope\n   * @returns The confirmation record if valid, undefined otherwise\n   */\n  checkConfirmation(operation: string, elementType?: string): ConfirmationRecord | undefined {\n    this.touch();\n\n    const key = this.getConfirmationKey(operation, elementType);\n    let confirmation = this.state.confirmations.get(key);\n\n    // Fall back to unscoped confirmation when element-type-scoped key not found.\n    // A session-wide confirmation for \"create_element\" covers \"create_element:skill\" etc.\n    if (!confirmation && elementType) {\n      confirmation = this.state.confirmations.get(operation);\n    }\n\n    if (!confirmation) {\n      return undefined;\n    }\n\n    // Increment use count\n    confirmation.useCount++;\n\n    // For CONFIRM_SINGLE_USE, invalidate after first use\n    if (confirmation.permissionLevel === 'CONFIRM_SINGLE_USE') {\n      // Delete whichever key matched (scoped or unscoped)\n      if (this.state.confirmations.has(key)) {\n        this.state.confirmations.delete(key);\n      } else {\n        this.state.confirmations.delete(operation);\n      }\n    }\n\n    return confirmation;\n  }\n\n  /**\n   * Check if an operation has a session confirmation WITHOUT consuming it.\n   * Use this to check status without affecting the confirmation state.\n   *\n   * @param operation - The operation to check\n   * @param elementType - Optional element type scope\n   * @returns The confirmation record if exists, undefined otherwise\n   */\n  peekConfirmation(operation: string, elementType?: string): ConfirmationRecord | undefined {\n    const key = this.getConfirmationKey(operation, elementType);\n    return this.state.confirmations.get(key);\n  }\n\n  /**\n   * Revoke a confirmation for an operation.\n   *\n   * @param operation - The operation to revoke\n   * @param elementType - Optional element type scope\n   * @returns true if a confirmation was revoked\n   */\n  revokeConfirmation(operation: string, elementType?: string): boolean {\n    this.touch();\n    const key = this.getConfirmationKey(operation, elementType);\n    return this.state.confirmations.delete(key);\n  }\n\n  /**\n   * Revoke all confirmations for this session.\n   * Useful when security-sensitive changes occur.\n   */\n  revokeAllConfirmations(): void {\n    this.touch();\n    this.state.confirmations.clear();\n  }\n\n  /**\n   * Get all active confirmations for this session.\n   * Useful for debugging and audit logging.\n   */\n  getActiveConfirmations(): ConfirmationRecord[] {\n    return Array.from(this.state.confirmations.values());\n  }\n\n  // ── CLI Approval Store (Issue #625 Phase 3) ────────────────────\n\n  /**\n   * Create a CLI approval request.\n   * Returns a unique request ID (format: cli-<UUIDv4>).\n   */\n  createCliApprovalRequest(\n    toolName: string,\n    toolInput: Record<string, unknown>,\n    riskLevel: string,\n    riskScore: number,\n    irreversible: boolean,\n    denyReason: string,\n    policySource?: string,\n    ttlMs?: number,\n  ): string {\n    this.touch();\n    this.expireStaleApprovals(true); // Force sweep on write path to ensure capacity\n\n    // LRU eviction at max capacity\n    if (this.state.cliApprovals.size >= this.maxCliApprovals) {\n      const oldestKey = this.state.cliApprovals.keys().next().value;\n      if (oldestKey) {\n        this.state.cliApprovals.delete(oldestKey);\n      }\n    }\n\n    const requestId = `cli-${randomUUID()}`;\n    // Clamp ttlMs to valid bounds (1s-24h) if provided\n    const clampedTtl = ttlMs != null\n      ? Math.max(MIN_APPROVAL_TTL_MS, Math.min(MAX_APPROVAL_TTL_MS, ttlMs))\n      : undefined;\n    const record: CliApprovalRecord = {\n      requestId,\n      toolName,\n      toolInput,\n      riskLevel,\n      riskScore,\n      irreversible,\n      requestedAt: new Date().toISOString(),\n      consumed: false,\n      scope: 'single',\n      denyReason,\n      policySource,\n      ttlMs: clampedTtl,\n    };\n    this.state.cliApprovals.set(requestId, record);\n    return requestId;\n  }\n\n  /**\n   * Approve a pending CLI approval request.\n   * Sets approvedAt, and promotes to session approvals if tool_session scope.\n   *\n   * @returns The approved record, or undefined if not found\n   */\n  approveCliRequest(requestId: string, scope: CliApprovalScope = 'single'): CliApprovalRecord | undefined {\n    this.touch();\n    const record = this.state.cliApprovals.get(requestId);\n    if (!record || record.approvedAt) {\n      return undefined;\n    }\n\n    record.approvedAt = new Date().toISOString();\n    record.scope = scope;\n\n    // Promote to session approvals if tool_session scope\n    if (scope === 'tool_session') {\n      this.state.cliSessionApprovals.set(record.toolName, record);\n    }\n\n    return record;\n  }\n\n  /**\n   * Check if a CLI tool call has a valid approval.\n   * Checks session approvals first (fast path), then individual approvals.\n   * Consumes single-scope approvals on use.\n   *\n   * @returns The matching approval record, or undefined\n   */\n  checkCliApproval(toolName: string, _toolInput: Record<string, unknown>): CliApprovalRecord | undefined {\n    this.touch();\n    this.expireStaleApprovals();\n\n    // Fast path: check session-scoped approvals by tool name\n    const sessionApproval = this.state.cliSessionApprovals.get(toolName);\n    if (sessionApproval) {\n      return sessionApproval;\n    }\n\n    // Check individual approvals\n    for (const [, record] of this.state.cliApprovals) {\n      if (record.toolName === toolName && record.approvedAt && !record.consumed) {\n        if (record.scope === 'single') {\n          record.consumed = true;\n        }\n        return record;\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Get all pending (unapproved) CLI approval requests.\n   * Forces expiry sweep to ensure accurate user-facing results.\n   */\n  getPendingCliApprovals(): CliApprovalRecord[] {\n    this.expireStaleApprovals(true);\n    const pending: CliApprovalRecord[] = [];\n    for (const [, record] of this.state.cliApprovals) {\n      if (!record.approvedAt) {\n        pending.push(record);\n      }\n    }\n    return pending;\n  }\n\n  /**\n   * Expire stale approval requests.\n   * Uses per-record ttlMs if set, otherwise DEFAULT_APPROVAL_TTL_MS (5 minutes).\n   *\n   * @param force - Skip throttle check (used by write paths that must ensure capacity)\n   */\n  private expireStaleApprovals(force = false): void {\n    const now = Date.now();\n    if (!force && now - this.lastExpirySweep < EXPIRY_SWEEP_INTERVAL_MS) return;\n    this.lastExpirySweep = now;\n\n    for (const [key, record] of this.state.cliApprovals) {\n      const ttl = record.ttlMs ?? DEFAULT_APPROVAL_TTL_MS;\n      const age = now - new Date(record.requestedAt).getTime();\n      // Evict stale pending requests AND consumed single-use approvals (#1782)\n      if (age > ttl && (!record.approvedAt || record.consumed)) {\n        this.state.cliApprovals.delete(key);\n      }\n    }\n  }\n\n  /**\n   * Get a summary of the session state.\n   * Safe to expose for debugging without revealing sensitive data.\n   */\n  getSummary(): {\n    sessionId: string;\n    clientInfo?: ClientInfo;\n    createdAt: string;\n    lastActivity: string;\n    confirmationCount: number;\n    cliApprovalCount: number;\n    permissionPromptActive: boolean;\n  } {\n    return {\n      sessionId: this.state.sessionId,\n      clientInfo: this.state.clientInfo,\n      createdAt: this.state.createdAt,\n      lastActivity: this.state.lastActivity,\n      confirmationCount: this.state.confirmations.size,\n      cliApprovalCount: this.state.cliApprovals.size,\n      permissionPromptActive: this.state.permissionPromptActive,\n    };\n  }\n\n  /**\n   * Generate a unique key for confirmation lookups.\n   * Combines operation and optional element type.\n   */\n  private getConfirmationKey(operation: string, elementType?: string): string {\n    return elementType ? `${operation}:${elementType}` : operation;\n  }\n}\n"]}