@compilr-dev/cli 0.5.0 → 0.5.2

package/dist/ui/overlay/impl/pending-overlay-v2.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Pending Requests Overlay V2
+ *
+ * Modal overlay for viewing and responding to pending requests from background agents.
+ * Users can approve, deny, or view details of each request.
+ *
+ * Phase 3b: Background Agents
+ */
+import { BaseOverlayV2 } from '../../base/index.js';
+import type { RenderContext, OverlayAction, KeyEvent } from '../index.js';
+import { type PendingRequest } from '../../../multi-agent/index.js';
+export type PendingOverlayResult = {
+    type: 'closed';
+} | {
+    type: 'respond';
+    request: PendingRequest;
+};
+interface PendingOverlayState {
+    /** Currently selected request index */
+    selectedIndex: number;
+    /** Requests snapshot at render time */
+    requests: PendingRequest[];
+    /** Whether we're showing a diff detail view */
+    showingDiff: boolean;
+    /** Scroll offset in diff view */
+    diffScrollOffset: number;
+    /** Pre-rendered diff lines (colored) */
+    diffLines: string[];
+    /** Which request the diff is for */
+    diffRequestId: string;
+}
+export declare class PendingOverlayV2 extends BaseOverlayV2<PendingOverlayState, PendingOverlayResult> {
+    readonly type: "inline";
+    readonly id = "pending-overlay-v2";
+    /** Active VS Code diff watchers, keyed by pending request ID */
+    private readonly vsDiffWatchers;
+    constructor();
+    protected renderContent(context: RenderContext): string[];
+    private renderListView;
+    private renderDiffView;
+    handleKey(key: KeyEvent): OverlayAction<PendingOverlayResult>;
+    private handleListKey;
+    /**
+     * Cancel an active VS Code diff for a pending request (if any).
+     * Called when the request is resolved from the terminal.
+     */
+    private cancelVSDiffForRequest;
+    private handleDiffKey;
+    getCloseSummary(result: PendingOverlayResult): string | null;
+}
+export {};

package/dist/ui/overlay/impl/pending-overlay-v2.js

@@ -0,0 +1,445 @@
+/**
+ * Pending Requests Overlay V2
+ *
+ * Modal overlay for viewing and responding to pending requests from background agents.
+ * Users can approve, deny, or view details of each request.
+ *
+ * Phase 3b: Background Agents
+ */
+import chalk from 'chalk';
+import { getStyles } from '../../../themes/index.js';
+import { BaseOverlayV2, truncate } from '../../base/index.js';
+import * as terminal from '../../terminal.js';
+import * as diff from '../../diff.js';
+import { isVSDiffAvailable } from '../../../utils/vscode-detect.js';
+import { openVSCodeDiffForTool, cancelDiffRequest, waitForDiffResponse, } from '../../vscode-diff-ipc.js';
+import { getPendingRequestsManager, } from '../../../multi-agent/index.js';
+// Fixed height for diff view content area
+const DIFF_VIEW_CONTENT_LINES = 15;
+// Tool names that support diff viewing
+const DIFFABLE_TOOLS = new Set(['edit', 'write_file', 'write']);
+// =============================================================================
+// Helpers
+// =============================================================================
+/**
+ * Check if a pending request has a diffable tool
+ */
+function isDiffableRequest(req) {
+    if (req.type !== 'permission' || !req.context)
+        return false;
+    const ctx = req.context;
+    return typeof ctx.toolName === 'string' && DIFFABLE_TOOLS.has(ctx.toolName);
+}
+/**
+ * Generate diff lines for a pending request.
+ * Returns an array of formatted lines, or null if diff can't be generated.
+ */
+function generateDiffForRequest(req) {
+    if (!req.context)
+        return null;
+    const ctx = req.context;
+    if (!ctx.toolName || !ctx.input)
+        return null;
+    const s = getStyles();
+    const toolName = ctx.toolName;
+    const input = ctx.input;
+    if (toolName === 'edit') {
+        const filePath = (input.filePath ?? input.file_path ?? input.path ?? '');
+        const oldText = (input.oldString ?? input.old_string ?? input.old_text ?? '');
+        const newText = (input.newString ?? input.new_string ?? input.new_text ?? '');
+        const replaceAll = Boolean(input.replaceAll ?? input.replace_all);
+        if (!filePath || !oldText)
+            return null;
+        const editDiff = diff.generateEditDiff(filePath, oldText, newText, replaceAll);
+        if (!editDiff) {
+            // Fallback: show raw old/new text
+            const lines = [];
+            lines.push(s.primary(`File: ${filePath}`));
+            lines.push('');
+            lines.push(s.muted('Could not read file to generate diff.'));
+            lines.push('');
+            lines.push(s.muted('Old text:'));
+            for (const line of oldText.split('\n').slice(0, 20)) {
+                lines.push('  ' + line);
+            }
+            lines.push('');
+            lines.push(s.muted('New text:'));
+            for (const line of newText.split('\n').slice(0, 20)) {
+                lines.push('  ' + line);
+            }
+            return lines;
+        }
+        const header = diff.formatDiffHeader(filePath, editDiff.additions, editDiff.removals);
+        return [header, '', ...editDiff.lines];
+    }
+    if (toolName === 'write_file' || toolName === 'write') {
+        const filePath = (input.path ?? input.file_path ?? input.filePath ?? '');
+        const content = (input.content ?? '');
+        if (!filePath || !content)
+            return null;
+        const writeDiff = diff.generateWriteDiff(filePath, content, true);
+        const header = diff.formatWriteHeader(filePath, writeDiff.additions, true);
+        return [header, '', ...writeDiff.lines];
+    }
+    return null;
+}
+// =============================================================================
+// Pending Overlay V2 Class
+// =============================================================================
+export class PendingOverlayV2 extends BaseOverlayV2 {
+    type = 'inline';
+    id = 'pending-overlay-v2';
+    /** Active VS Code diff watchers, keyed by pending request ID */
+    vsDiffWatchers = new Map();
+    constructor() {
+        const manager = getPendingRequestsManager();
+        const requests = manager.getAll();
+        super({
+            selectedIndex: 0,
+            requests,
+            showingDiff: false,
+            diffScrollOffset: 0,
+            diffLines: [],
+            diffRequestId: '',
+        });
+        // Set minimum height for stable rendering
+        this.minHeight = 10;
+    }
+    renderContent(context) {
+        if (this.state.showingDiff) {
+            return this.renderDiffView(context);
+        }
+        return this.renderListView(context);
+    }
+    renderListView(context) {
+        const s = context.styles;
+        const lines = [];
+        const cols = terminal.getTerminalWidth();
+        const border = s.muted('─'.repeat(Math.max(1, cols - 1)));
+        // Refresh requests each render
+        const manager = getPendingRequestsManager();
+        this.state.requests = manager.getAll();
+        // Header
+        lines.push(border);
+        lines.push(' ' + chalk.bold('Pending Requests') + s.muted(` (${String(this.state.requests.length)} total)`));
+        lines.push(border);
+        lines.push('');
+        if (this.state.requests.length === 0) {
+            lines.push(s.muted('  No pending requests from background agents.'));
+            lines.push('');
+        }
+        else {
+            // Render each request
+            for (let i = 0; i < this.state.requests.length; i++) {
+                const req = this.state.requests[i];
+                const isSelected = i === this.state.selectedIndex;
+                const prefix = isSelected ? ' ❯ ' : '   ';
+                // Request header: [mascot] agent: prompt
+                const header = `${req.mascot} $${req.agentId}: ${req.prompt}`;
+                const maxHeaderLen = cols - 6;
+                const truncHeader = truncate(header, maxHeaderLen);
+                if (isSelected) {
+                    lines.push(s.primary(prefix + `${String(i + 1)}. ${truncHeader}`));
+                }
+                else {
+                    lines.push(s.muted(prefix + `${String(i + 1)}. ${truncHeader}`));
+                }
+                // Type indicator
+                const typeLabel = req.type === 'permission' ? 'Permission request' : 'Question';
+                lines.push(s.muted(`      Type: ${typeLabel}`));
+                // Actions line (only for selected)
+                if (isSelected) {
+                    if (req.type === 'question') {
+                        lines.push(s.info('      [r]espond · [d]eny/skip'));
+                    }
+                    else if (isDiffableRequest(req)) {
+                        lines.push(s.info('      [a]pprove  [d]eny  [v] diff'));
+                    }
+                    else {
+                        lines.push(s.info('      [a]pprove  [d]eny'));
+                    }
+                }
+                else {
+                    lines.push('');
+                }
+                lines.push('');
+            }
+        }
+        // Footer
+        lines.push(border);
+        if (this.state.requests.length > 0) {
+            // Check if selected request is a question
+            const selectedReq = this.state.requests[this.state.selectedIndex];
+            if (selectedReq && selectedReq.type === 'question') {
+                lines.push(s.muted(' ↑↓ Navigate · r/Enter Respond · d Deny/Skip · Esc Close'));
+            }
+            else if (selectedReq && isDiffableRequest(selectedReq)) {
+                lines.push(s.muted(' ↑↓ Navigate · a Approve · d Deny · v View diff · Esc Close'));
+            }
+            else {
+                lines.push(s.muted(' ↑↓ Navigate · a Approve · d Deny · Esc Close'));
+            }
+        }
+        else {
+            lines.push(s.muted(' Esc Close'));
+        }
+        return lines;
+    }
+    renderDiffView(context) {
+        const s = context.styles;
+        const cols = terminal.getTerminalWidth();
+        const lines = [];
+        const border = s.muted('─'.repeat(Math.max(1, cols - 1)));
+        // Refresh requests each render
+        const manager = getPendingRequestsManager();
+        this.state.requests = manager.getAll();
+        // Find the request this diff is for (may have been resolved externally via VS Code)
+        const req = this.state.requests.find(r => r.id === this.state.diffRequestId);
+        if (!req) {
+            // Request was resolved externally — return to list view
+            this.state.showingDiff = false;
+            return this.renderListView(context);
+        }
+        const agentLabel = `$${req.agentId}`;
+        const ctx = req.context;
+        const filePath = ctx?.input
+            ? (ctx.input.filePath ?? ctx.input.file_path ?? ctx.input.path ?? '')
+            : '';
+        const fileName = filePath.split('/').pop() || filePath;
+        // Header
+        lines.push(border);
+        lines.push(' ' + chalk.bold('Diff: ') + s.primary(fileName) + s.muted(agentLabel ? ` (${agentLabel})` : ''));
+        lines.push(border);
+        lines.push('');
+        // Content with scroll
+        const contentLines = this.state.diffLines;
+        const visibleLines = DIFF_VIEW_CONTENT_LINES;
+        const endLine = Math.min(this.state.diffScrollOffset + visibleLines, contentLines.length);
+        for (let i = this.state.diffScrollOffset; i < endLine; i++) {
+            const line = contentLines[i];
+            const safeLine = truncate(line, cols - 2);
+            lines.push(' ' + safeLine);
+        }
+        // Pad to fixed height
+        const renderedLines = endLine - this.state.diffScrollOffset;
+        for (let i = renderedLines; i < DIFF_VIEW_CONTENT_LINES; i++) {
+            lines.push('');
+        }
+        // Footer with scroll indicator
+        lines.push('');
+        const scrollInfo = contentLines.length > visibleLines
+            ? s.muted(` [${String(this.state.diffScrollOffset + 1)}-${String(endLine)}/${String(contentLines.length)}]`)
+            : '';
+        lines.push(border);
+        lines.push(s.muted(' ↑↓/PgUp/PgDn Scroll · a Approve · d Deny · Esc Back') + scrollInfo);
+        return lines;
+    }
+    handleKey(key) {
+        if (this.state.showingDiff) {
+            return this.handleDiffKey(key);
+        }
+        return this.handleListKey(key);
+    }
+    handleListKey(key) {
+        // Escape or Ctrl+C = close
+        if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+            // Cancel all active VS Code diff watchers
+            for (const [, watcher] of this.vsDiffWatchers) {
+                watcher.abort();
+                cancelDiffRequest(watcher.diffReqId);
+            }
+            this.vsDiffWatchers.clear();
+            return this.close({ type: 'closed' });
+        }
+        // No requests - just allow closing
+        if (this.state.requests.length === 0) {
+            return this.rerender();
+        }
+        const keyStr = key.char?.toLowerCase() ?? '';
+        // Arrow navigation
+        if (key.name === 'up') {
+            this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+            return this.rerender();
+        }
+        if (key.name === 'down') {
+            this.state.selectedIndex = Math.min(this.state.requests.length - 1, this.state.selectedIndex + 1);
+            return this.rerender();
+        }
+        // View diff (for permission-type with diffable tool)
+        if (keyStr === 'v') {
+            const req = this.state.requests[this.state.selectedIndex];
+            if (req && isDiffableRequest(req)) {
+                // Open VS Code diff if available
+                if (isVSDiffAvailable() && !this.vsDiffWatchers.has(req.id)) {
+                    const ctx = req.context;
+                    const diffReqId = openVSCodeDiffForTool({
+                        toolName: ctx.toolName,
+                        input: ctx.input,
+                        agentId: req.agentId,
+                    });
+                    if (diffReqId) {
+                        // Start background watcher for VS Code approve/deny response
+                        const { promise, abort } = waitForDiffResponse(diffReqId, 120_000);
+                        this.vsDiffWatchers.set(req.id, { abort, diffReqId });
+                        promise.then((response) => {
+                            if (response && !response.cancelled) {
+                                const manager = getPendingRequestsManager();
+                                const pending = manager.getAll().find(r => r.id === req.id);
+                                if (pending) {
+                                    manager.respond(req.id, { approved: response.accepted });
+                                    // Trigger overlay re-render to reflect the change
+                                    this.requestRender();
+                                }
+                            }
+                            this.vsDiffWatchers.delete(req.id);
+                        }).catch(() => {
+                            this.vsDiffWatchers.delete(req.id);
+                        });
+                    }
+                }
+                // Also show terminal diff view (for terminal-based approve/deny)
+                const terminalDiffLines = generateDiffForRequest(req);
+                if (terminalDiffLines) {
+                    this.state.showingDiff = true;
+                    this.state.diffScrollOffset = 0;
+                    this.state.diffLines = terminalDiffLines;
+                    this.state.diffRequestId = req.id;
+                    return this.rerender();
+                }
+            }
+            return this.rerender();
+        }
+        // Approve selected request (for permission-type only)
+        if (keyStr === 'a') {
+            const req = this.state.requests[this.state.selectedIndex];
+            if (req && req.type === 'permission') {
+                this.cancelVSDiffForRequest(req.id);
+                const manager = getPendingRequestsManager();
+                manager.respond(req.id, { approved: true });
+                // Auto-close if no requests remain
+                if (manager.getCount() === 0) {
+                    return this.close({ type: 'closed' });
+                }
+                // Update selection if needed
+                if (this.state.selectedIndex >= this.state.requests.length - 1) {
+                    this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+                }
+            }
+            return this.rerender();
+        }
+        // Deny selected request
+        if (keyStr === 'd') {
+            const req = this.state.requests[this.state.selectedIndex];
+            if (req) {
+                this.cancelVSDiffForRequest(req.id);
+                const manager = getPendingRequestsManager();
+                manager.respond(req.id, { approved: false });
+                // Auto-close if no requests remain
+                if (manager.getCount() === 0) {
+                    return this.close({ type: 'closed' });
+                }
+                // Update selection if needed
+                if (this.state.selectedIndex >= this.state.requests.length - 1) {
+                    this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+                }
+            }
+            return this.rerender();
+        }
+        // Respond to question with standard overlay (r or Enter)
+        if (keyStr === 'r' || key.name === 'return') {
+            const req = this.state.requests[this.state.selectedIndex];
+            if (req && req.type === 'question') {
+                // Close overlay and return the request to show standard overlay
+                return this.close({ type: 'respond', request: req });
+            }
+        }
+        return this.rerender();
+    }
+    /**
+     * Cancel an active VS Code diff for a pending request (if any).
+     * Called when the request is resolved from the terminal.
+     */
+    cancelVSDiffForRequest(pendingReqId) {
+        const watcher = this.vsDiffWatchers.get(pendingReqId);
+        if (watcher) {
+            watcher.abort();
+            cancelDiffRequest(watcher.diffReqId);
+            this.vsDiffWatchers.delete(pendingReqId);
+        }
+    }
+    handleDiffKey(key) {
+        const keyStr = key.char?.toLowerCase() ?? '';
+        // Escape or q = go back to list view
+        if (key.name === 'escape' || keyStr === 'q') {
+            this.state.showingDiff = false;
+            return this.rerender();
+        }
+        // Approve from diff view
+        if (keyStr === 'a') {
+            const req = this.state.requests.find(r => r.id === this.state.diffRequestId);
+            if (req && req.type === 'permission') {
+                this.cancelVSDiffForRequest(req.id);
+                const manager = getPendingRequestsManager();
+                manager.respond(req.id, { approved: true });
+                this.state.showingDiff = false;
+                // Auto-close if no requests remain
+                if (manager.getCount() === 0) {
+                    return this.close({ type: 'closed' });
+                }
+                // Update selection if needed
+                if (this.state.selectedIndex >= this.state.requests.length - 1) {
+                    this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+                }
+            }
+            return this.rerender();
+        }
+        // Deny from diff view
+        if (keyStr === 'd') {
+            const req = this.state.requests.find(r => r.id === this.state.diffRequestId);
+            if (req) {
+                this.cancelVSDiffForRequest(req.id);
+                const manager = getPendingRequestsManager();
+                manager.respond(req.id, { approved: false });
+                this.state.showingDiff = false;
+                // Auto-close if no requests remain
+                if (manager.getCount() === 0) {
+                    return this.close({ type: 'closed' });
+                }
+                // Update selection if needed
+                if (this.state.selectedIndex >= this.state.requests.length - 1) {
+                    this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+                }
+            }
+            return this.rerender();
+        }
+        // Scroll
+        const visibleLines = DIFF_VIEW_CONTENT_LINES;
+        const maxOffset = Math.max(0, this.state.diffLines.length - visibleLines);
+        if (key.name === 'up') {
+            this.state.diffScrollOffset = Math.max(0, this.state.diffScrollOffset - 1);
+        }
+        else if (key.name === 'pageup') {
+            this.state.diffScrollOffset = Math.max(0, this.state.diffScrollOffset - visibleLines);
+        }
+        else if (key.name === 'down') {
+            this.state.diffScrollOffset = Math.min(maxOffset, this.state.diffScrollOffset + 1);
+        }
+        else if (key.name === 'pagedown') {
+            this.state.diffScrollOffset = Math.min(maxOffset, this.state.diffScrollOffset + visibleLines);
+        }
+        return this.rerender();
+    }
+    getCloseSummary(result) {
+        // Don't show summary if we're responding to a question (will show overlay)
+        if (result.type === 'respond') {
+            return null;
+        }
+        const s = getStyles();
+        const manager = getPendingRequestsManager();
+        const remaining = manager.getCount();
+        if (remaining > 0) {
+            return s.muted(`Pending requests: ${String(remaining)} remaining`);
+        }
+        return s.success('All pending requests resolved.');
+    }
+}

package/dist/ui/overlay/impl/permission-overlay-v2.js

@@ -6,7 +6,7 @@
  */
 import chalk from 'chalk';
 import { getStyles } from '../../../themes/index.js';
-import { BaseOverlayV2 } from '../../base/index.js';
+import { BaseOverlayV2, truncate } from '../../base/index.js';
 import * as terminal from '../../terminal.js';
 // =============================================================================
 // Helpers
@@ -18,7 +18,7 @@ import * as terminal from '../../terminal.js';
 function formatValue(value, maxLen) {
     if (typeof value === 'string') {
         const singleLine = value.replace(/\r?\n|\r/g, '↵');
-        return singleLine.length > maxLen ? singleLine.slice(0, maxLen) + '...' : singleLine;
+        return truncate(singleLine, maxLen);
     }
     if (typeof value === 'boolean' || typeof value === 'number') {
         return String(value);
@@ -76,7 +76,7 @@ function formatArgs(toolName, args, maxWidth) {
         else {
             lines.push(prefix);
             const maxCmdLength = availableWidth * 3;
-            const truncatedCmd = cmd.length > maxCmdLength ? cmd.slice(0, maxCmdLength) + '...' : cmd;
+            const truncatedCmd = truncate(cmd, maxCmdLength);
             lines.push('  ' + truncatedCmd);
         }
         return lines;
@@ -242,7 +242,7 @@ export class PermissionOverlayV2 extends BaseOverlayV2 {
         const maxArgWidth = cols - 6;
         const argLines = formatArgs(this.options.toolName, this.options.args, maxArgWidth);
         for (const argLine of argLines) {
-            const safeArg = argLine.length > maxArgWidth ? argLine.slice(0, maxArgWidth - 3) + '...' : argLine;
+            const safeArg = truncate(argLine, maxArgWidth);
             lines.push('  ' + s.muted(safeArg));
         }
         lines.push('');
@@ -282,7 +282,7 @@ export class PermissionOverlayV2 extends BaseOverlayV2 {
         const endLine = Math.min(this.state.detailScrollOffset + visibleLines, contentLines.length);
         for (let i = this.state.detailScrollOffset; i < endLine; i++) {
             const line = contentLines[i];
-            const safeLine = line.length > cols - 4 ? line.slice(0, cols - 7) + '...' : line;
+            const safeLine = truncate(line, cols - 4);
             lines.push(' ' + safeLine);
         }
         // Pad to fixed height

package/dist/ui/overlay/impl/permissions-overlay-v2.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Permissions Overlay V2
+ *
+ * Modal overlay for managing tool permissions.
+ * 3 tabs:
+ * - Rules: View/edit permission rules (add, edit, delete, wildcards)
+ * - Mode: Set global permission mode
+ * - Session: View/revoke session grants, toggle auto-accept
+ *
+ * Uses BaseOverlayV2 for the new Overlay interface.
+ */
+import { BaseOverlayV2 } from '../../base/index.js';
+import type { RenderContext, OverlayAction, KeyEvent } from '../index.js';
+import { type PermissionRule, type PermissionLevel, type PermissionMode } from '../../../settings/index.js';
+interface SessionGrant {
+    toolName: string;
+    grantedAt: Date;
+}
+type EditMode = 'none' | 'edit-level' | 'add-step1' | 'add-step2' | 'add-step3' | 'confirm-reset' | 'confirm-delete' | 'confirm-mode-change';
+interface PermissionsState {
+    currentTab: number;
+    rules: PermissionRule[];
+    rulesSelectedIndex: number;
+    rulesScrollOffset: number;
+    editMode: EditMode;
+    editLevelIndex: number;
+    addInput: string;
+    addLevel: PermissionLevel;
+    addDescription: string;
+    modeSelectedIndex: number;
+    pendingMode: PermissionMode | null;
+    clearGrantsOnModeChange: boolean;
+    sessionGrants: SessionGrant[];
+    sessionSelectedIndex: number;
+    autoAcceptMode: boolean;
+    settingsChanged: boolean;
+}
+export interface PermissionsOverlayV2Result {
+    settingsChanged: boolean;
+}
+export interface PermissionsOverlayV2Options {
+    /** Session grants from PermissionManager */
+    sessionGrants?: Map<string, Date>;
+    /** Current auto-accept mode state */
+    autoAcceptMode?: boolean;
+    /** Callback to revoke a session grant */
+    onRevokeGrant?: (toolName: string) => void;
+    /** Callback to clear all session grants */
+    onClearGrants?: () => void;
+    /** Callback to toggle auto-accept mode */
+    onToggleAutoAccept?: (enabled: boolean) => void;
+    /** Callback to sync UI mode when permission mode changes */
+    onModeChange?: (newMode: PermissionMode) => void;
+}
+export declare class PermissionsOverlayV2 extends BaseOverlayV2<PermissionsState, PermissionsOverlayV2Result> {
+    readonly type: "inline";
+    readonly id = "permissions-overlay-v2";
+    protected minHeight: number;
+    private readonly options;
+    constructor(options?: PermissionsOverlayV2Options);
+    protected renderContent(context: RenderContext): string[];
+    private renderTabHeader;
+    private renderRulesTab;
+    private renderEditLevelMode;
+    private renderAddWizard;
+    private renderConfirmReset;
+    private renderConfirmDelete;
+    private getLevelDescription;
+    private renderModeTab;
+    private getModeDescription;
+    private renderModeChangeConfirm;
+    private renderSessionTab;
+    private formatTime;
+    private renderTabFooter;
+    handleKey(key: KeyEvent): OverlayAction<PermissionsOverlayV2Result>;
+    private handleRulesTabKey;
+    private handleEditLevelKey;
+    private handleAddWizardKey;
+    private handleConfirmResetKey;
+    private handleConfirmDeleteKey;
+    private handleModeTabKey;
+    private handleModeChangeConfirmKey;
+    private handleSessionTabKey;
+}
+export {};