clodds 1.1.0

package/dist/permissions/index.js

@@ -0,0 +1,929 @@
+"use strict";
+/**
+ * Permissions Module - Clawdbot-style exec approvals and command allowlisting
+ *
+ * Features:
+ * - Exec security modes (deny/allowlist/full)
+ * - Shell command allowlist engine with pattern matching
+ * - Approval gating with ask modes (off/on-miss/always)
+ * - Command chain parsing (&&, ||, |, ;)
+ * - Safe bins list (pre-approved utilities)
+ * - Tool profiles (minimal/coding/messaging/full)
+ * - Per-provider tool policies
+ * - Sandbox path enforcement
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.elevatedPermissions = exports.toolPolicies = exports.execApprovals = exports.ElevatedPermissions = exports.ToolPolicyManager = exports.ExecApprovalsManager = exports.TOOL_PROFILES = exports.TOOL_GROUPS = exports.SAFE_BINS = void 0;
+exports.splitCommandChain = splitCommandChain;
+exports.parseCommand = parseCommand;
+exports.resolveCommandPath = resolveCommandPath;
+exports.isSafeBin = isSafeBin;
+exports.matchesAllowlistPattern = matchesAllowlistPattern;
+exports.assertSandboxPath = assertSandboxPath;
+exports.resolveSandboxPath = resolveSandboxPath;
+const events_1 = require("events");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const logger_1 = require("../utils/logger");
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+/** Pre-approved safe binaries (low-risk utilities) */
+exports.SAFE_BINS = new Set([
+    'jq', 'grep', 'cut', 'sort', 'uniq', 'head', 'tail', 'tr', 'wc',
+    'awk', 'sed', 'cat', 'echo', 'printf', 'test', '[', 'true', 'false',
+    'date', 'basename', 'dirname', 'pwd', 'whoami', 'hostname',
+    'env', 'printenv', 'which', 'type', 'file',
+    'ls', 'find', 'stat', 'du', 'df', 'realpath', 'readlink',
+    'diff', 'comm', 'join', 'paste', 'column',
+    'xargs', 'tee', 'yes', 'seq', 'shuf',
+    'md5sum', 'sha256sum', 'sha1sum', 'base64',
+    'gzip', 'gunzip', 'zcat', 'bzip2', 'bunzip2', 'xz', 'unxz',
+    'tar', 'zip', 'unzip',
+]);
+/** Tool groups for policy expansion */
+exports.TOOL_GROUPS = {
+    'group:memory': ['memory_search', 'memory_get', 'memory_store'],
+    'group:web': ['web_search', 'web_fetch', 'web_browse'],
+    'group:fs': ['read_file', 'write_file', 'list_dir', 'file_search'],
+    'group:runtime': ['bash', 'exec', 'eval'],
+    'group:sessions': ['session_list', 'session_send', 'session_spawn', 'session_status'],
+    'group:messaging': ['message_send', 'message_edit', 'message_delete', 'message_react'],
+};
+/** Built-in tool profiles */
+exports.TOOL_PROFILES = {
+    minimal: ['session_status'],
+    coding: [
+        'session_status',
+        'group:fs',
+        'group:runtime',
+        'group:sessions',
+        'group:memory',
+    ],
+    messaging: [
+        'session_status',
+        'group:messaging',
+        'group:sessions',
+    ],
+    full: ['*'],
+    custom: [],
+};
+const DEFAULT_APPROVAL_TIMEOUT = 60000; // 1 minute
+const CONFIG_VERSION = 1;
+// =============================================================================
+// COMMAND PARSING
+// =============================================================================
+/** Shell command chain operators */
+const CHAIN_OPERATORS = ['&&', '||', '|', ';'];
+/**
+ * Split a command string into individual commands based on shell operators
+ */
+function splitCommandChain(command) {
+    const commands = [];
+    let current = '';
+    let inQuote = null;
+    let escape = false;
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i];
+        if (escape) {
+            current += char;
+            escape = false;
+            continue;
+        }
+        if (char === '\\') {
+            escape = true;
+            current += char;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            if (inQuote === char) {
+                inQuote = null;
+            }
+            else if (!inQuote) {
+                inQuote = char;
+            }
+            current += char;
+            continue;
+        }
+        if (!inQuote) {
+            // Check for chain operators
+            let foundOperator = false;
+            for (const op of CHAIN_OPERATORS) {
+                if (command.slice(i, i + op.length) === op) {
+                    if (current.trim()) {
+                        commands.push(current.trim());
+                    }
+                    current = '';
+                    i += op.length - 1;
+                    foundOperator = true;
+                    break;
+                }
+            }
+            if (foundOperator)
+                continue;
+        }
+        current += char;
+    }
+    if (current.trim()) {
+        commands.push(current.trim());
+    }
+    return commands;
+}
+/**
+ * Parse a command string into command and arguments
+ */
+function parseCommand(commandStr) {
+    const parts = [];
+    let current = '';
+    let inQuote = null;
+    let escape = false;
+    for (const char of commandStr) {
+        if (escape) {
+            current += char;
+            escape = false;
+            continue;
+        }
+        if (char === '\\') {
+            escape = true;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            if (inQuote === char) {
+                inQuote = null;
+            }
+            else if (!inQuote) {
+                inQuote = char;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === ' ' && !inQuote) {
+            if (current) {
+                parts.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current) {
+        parts.push(current);
+    }
+    return {
+        command: parts[0] || '',
+        args: parts.slice(1),
+    };
+}
+/**
+ * Resolve command to full path using PATH
+ */
+function resolveCommandPath(command) {
+    // If already absolute path
+    if ((0, path_1.isAbsolute)(command)) {
+        return (0, fs_1.existsSync)(command) ? command : null;
+    }
+    // Try to resolve using 'which' - use execFileSync to prevent command injection
+    try {
+        const result = (0, child_process_1.execFileSync)('which', [command], { encoding: 'utf8', timeout: 5000 });
+        return result.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a command is in the safe bins list
+ */
+function isSafeBin(command) {
+    const basename = command.split('/').pop() || command;
+    return exports.SAFE_BINS.has(basename);
+}
+// =============================================================================
+// ALLOWLIST MATCHING
+// =============================================================================
+/**
+ * Check if a command matches an allowlist pattern
+ */
+function matchesAllowlistPattern(command, fullCommand, entry) {
+    switch (entry.type) {
+        case 'prefix':
+            return fullCommand.startsWith(entry.pattern) || command.startsWith(entry.pattern);
+        case 'glob':
+            // Simple glob matching (supports * and ?)
+            const regex = new RegExp('^' + entry.pattern
+                .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+                .replace(/\*/g, '.*')
+                .replace(/\?/g, '.') + '$');
+            return regex.test(command) || regex.test(fullCommand);
+        case 'regex':
+            try {
+                const re = new RegExp(entry.pattern);
+                return re.test(command) || re.test(fullCommand);
+            }
+            catch {
+                return false;
+            }
+        default:
+            return false;
+    }
+}
+/**
+ * Validate a path is within the sandbox
+ */
+function assertSandboxPath(path, config) {
+    const normalizedPath = (0, path_1.normalize)((0, path_1.resolve)(path));
+    const normalizedRoot = (0, path_1.normalize)((0, path_1.resolve)(config.root));
+    // Check for path traversal
+    if (normalizedPath.includes('..')) {
+        throw new Error(`Path traversal detected: ${path}`);
+    }
+    // Check path is within root
+    if (!normalizedPath.startsWith(normalizedRoot)) {
+        throw new Error(`Path escapes sandbox: ${path}`);
+    }
+    // Check for symlinks if not allowed
+    if (!config.allowSymlinks && (0, fs_1.existsSync)(path)) {
+        try {
+            const stats = (0, fs_1.lstatSync)(path);
+            if (stats.isSymbolicLink()) {
+                const realPath = (0, fs_1.realpathSync)(path);
+                if (!realPath.startsWith(normalizedRoot)) {
+                    throw new Error(`Symlink escapes sandbox: ${path} -> ${realPath}`);
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+}
+/**
+ * Resolve a path within the sandbox
+ */
+function resolveSandboxPath(path, config) {
+    const resolved = (0, path_1.isAbsolute)(path) ? path : (0, path_1.join)(config.root, path);
+    assertSandboxPath(resolved, config);
+    return resolved;
+}
+// =============================================================================
+// EXEC APPROVALS MANAGER
+// =============================================================================
+class ExecApprovalsManager extends events_1.EventEmitter {
+    config;
+    configPath;
+    pendingPath;
+    decisionsPath;
+    pendingApprovals = new Map();
+    constructor(configPath) {
+        super();
+        this.configPath = configPath || (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'exec-approvals.json');
+        this.pendingPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'exec-approvals.pending.json');
+        this.decisionsPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'exec-approvals.decisions.json');
+        this.config = this.loadConfig();
+        const pending = this.loadPendingFile();
+        const now = Date.now();
+        for (const entry of pending.pending) {
+            const expiresAt = entry.expiresAt ? new Date(entry.expiresAt) : undefined;
+            if (expiresAt && expiresAt.getTime() <= now) {
+                continue;
+            }
+            this.pendingApprovals.set(entry.id, {
+                id: entry.id,
+                command: entry.command,
+                args: entry.args,
+                fullCommand: entry.fullCommand,
+                agentId: entry.agentId,
+                sessionId: entry.sessionId,
+                timestamp: new Date(entry.timestamp),
+                expiresAt,
+                requester: entry.requester,
+                status: 'pending',
+            });
+        }
+        const decisionPoller = setInterval(() => {
+            this.applyDecisionsFromDisk();
+        }, 1000);
+        decisionPoller.unref?.();
+    }
+    loadConfig() {
+        try {
+            if ((0, fs_1.existsSync)(this.configPath)) {
+                const data = JSON.parse((0, fs_1.readFileSync)(this.configPath, 'utf-8'));
+                if (data.version === CONFIG_VERSION) {
+                    return data;
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Failed to load exec approvals config');
+        }
+        // Return default config
+        return {
+            version: CONFIG_VERSION,
+            defaults: {
+                mode: 'allowlist',
+                ask: 'on-miss',
+                approvalTimeout: DEFAULT_APPROVAL_TIMEOUT,
+                fallbackMode: 'deny',
+            },
+            agents: {},
+        };
+    }
+    refreshConfig() {
+        this.config = this.loadConfig();
+    }
+    saveConfig() {
+        try {
+            const dir = (0, path_1.dirname)(this.configPath);
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(this.configPath, JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Failed to save exec approvals config');
+        }
+    }
+    loadPendingFile() {
+        try {
+            if ((0, fs_1.existsSync)(this.pendingPath)) {
+                const data = JSON.parse((0, fs_1.readFileSync)(this.pendingPath, 'utf-8'));
+                if (data.version === 1 && Array.isArray(data.pending)) {
+                    return data;
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Failed to load exec approvals pending file');
+        }
+        return {
+            version: 1,
+            pending: [],
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    savePendingFile(pending) {
+        try {
+            const dir = (0, path_1.dirname)(this.pendingPath);
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            const data = {
+                version: 1,
+                pending,
+                updatedAt: new Date().toISOString(),
+            };
+            (0, fs_1.writeFileSync)(this.pendingPath, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Failed to save exec approvals pending file');
+        }
+    }
+    loadDecisionsFile() {
+        try {
+            if ((0, fs_1.existsSync)(this.decisionsPath)) {
+                const data = JSON.parse((0, fs_1.readFileSync)(this.decisionsPath, 'utf-8'));
+                if (data.version === 1 && Array.isArray(data.decisions)) {
+                    return data;
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Failed to load exec approvals decisions file');
+        }
+        return {
+            version: 1,
+            decisions: [],
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    saveDecisionsFile(decisions) {
+        try {
+            const dir = (0, path_1.dirname)(this.decisionsPath);
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            const data = {
+                version: 1,
+                decisions,
+                updatedAt: new Date().toISOString(),
+            };
+            (0, fs_1.writeFileSync)(this.decisionsPath, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Failed to save exec approvals decisions file');
+        }
+    }
+    persistPending() {
+        const pending = Array.from(this.pendingApprovals.values())
+            .filter((req) => req.status === 'pending')
+            .map((req) => ({
+            id: req.id,
+            command: req.command,
+            args: req.args,
+            fullCommand: req.fullCommand,
+            agentId: req.agentId,
+            sessionId: req.sessionId,
+            timestamp: req.timestamp.toISOString(),
+            expiresAt: req.expiresAt?.toISOString(),
+            requester: req.requester,
+        }));
+        this.savePendingFile(pending);
+    }
+    consumeDecisionForRequest(requestId) {
+        const data = this.loadDecisionsFile();
+        if (data.decisions.length === 0)
+            return null;
+        const remaining = [];
+        let matched = null;
+        for (const decision of data.decisions) {
+            if (!matched && decision.id === requestId) {
+                matched = decision;
+            }
+            else {
+                remaining.push(decision);
+            }
+        }
+        if (matched) {
+            this.saveDecisionsFile(remaining);
+        }
+        return matched;
+    }
+    applyDecisionsFromDisk() {
+        const data = this.loadDecisionsFile();
+        if (data.decisions.length === 0)
+            return;
+        const remaining = [];
+        let changed = false;
+        for (const decision of data.decisions) {
+            const request = this.pendingApprovals.get(decision.id);
+            if (!request) {
+                continue;
+            }
+            request.status = decision.decision === 'deny' ? 'denied' : 'approved';
+            request.decision = decision.decision;
+            request.decidedBy = decision.decidedBy;
+            request.decidedAt = new Date(decision.decidedAt);
+            this.pendingApprovals.delete(decision.id);
+            changed = true;
+            if (decision.decision === 'allow-always' && !request.awaitingDecision) {
+                this.addToAllowlist(request.agentId, request.command, 'prefix', {
+                    description: 'Auto-added via approval',
+                    addedBy: decision.decidedBy,
+                });
+            }
+            this.emit('approval:decision', {
+                requestId: decision.id,
+                decision: decision.decision,
+                decidedBy: decision.decidedBy,
+            });
+        }
+        if (remaining.length !== data.decisions.length) {
+            this.saveDecisionsFile(remaining);
+        }
+        if (changed) {
+            this.persistPending();
+        }
+    }
+    /**
+     * Get security config for an agent
+     */
+    getSecurityConfig(agentId) {
+        return this.config.agents[agentId]?.security || this.config.defaults;
+    }
+    /**
+     * Set security config for an agent
+     */
+    setSecurityConfig(agentId, config) {
+        if (!this.config.agents[agentId]) {
+            this.config.agents[agentId] = { allowlist: [] };
+        }
+        this.config.agents[agentId].security = {
+            ...this.config.defaults,
+            ...this.config.agents[agentId].security,
+            ...config,
+        };
+        this.saveConfig();
+    }
+    /**
+     * Get allowlist for an agent
+     */
+    getAllowlist(agentId) {
+        return this.config.agents[agentId]?.allowlist || [];
+    }
+    /**
+     * Add to allowlist
+     */
+    addToAllowlist(agentId, pattern, type = 'prefix', options = {}) {
+        if (!this.config.agents[agentId]) {
+            this.config.agents[agentId] = { allowlist: [] };
+        }
+        const entry = {
+            id: (0, crypto_1.randomUUID)(),
+            pattern,
+            type,
+            addedAt: Date.now(),
+            ...options,
+        };
+        this.config.agents[agentId].allowlist.push(entry);
+        this.saveConfig();
+        logger_1.logger.info({ agentId, pattern, type }, 'Added to allowlist');
+        return entry;
+    }
+    /**
+     * Remove from allowlist
+     */
+    removeFromAllowlist(agentId, entryId) {
+        const agent = this.config.agents[agentId];
+        if (!agent)
+            return false;
+        const index = agent.allowlist.findIndex(e => e.id === entryId);
+        if (index === -1)
+            return false;
+        agent.allowlist.splice(index, 1);
+        this.saveConfig();
+        logger_1.logger.info({ agentId, entryId }, 'Removed from allowlist');
+        return true;
+    }
+    /**
+     * Check if a command is allowed
+     */
+    async checkCommand(agentId, fullCommand, options = {}) {
+        this.refreshConfig();
+        const security = this.getSecurityConfig(agentId);
+        const waitForApproval = options.waitForApproval !== false;
+        // Full mode - allow everything
+        if (security.mode === 'full') {
+            return { allowed: true, reason: 'Full access mode' };
+        }
+        // Deny mode - block everything
+        if (security.mode === 'deny') {
+            return { allowed: false, reason: 'Deny mode - all commands blocked' };
+        }
+        // Parse command chain
+        const commands = splitCommandChain(fullCommand);
+        for (const cmdStr of commands) {
+            const { command, args } = parseCommand(cmdStr);
+            // Check safe bins
+            if (isSafeBin(command)) {
+                continue; // Safe bin, check next command in chain
+            }
+            // Check allowlist
+            const allowlist = this.getAllowlist(agentId);
+            const matchedEntry = allowlist.find(entry => matchesAllowlistPattern(command, cmdStr, entry));
+            if (matchedEntry) {
+                // Update last used
+                matchedEntry.lastUsedAt = Date.now();
+                matchedEntry.lastResolvedPath = resolveCommandPath(command) || undefined;
+                this.saveConfig();
+                continue; // Allowed, check next command
+            }
+            // Not in allowlist - check ask mode
+            if (security.ask === 'off' || options.skipApproval) {
+                return { allowed: false, reason: `Command not in allowlist: ${command}` };
+            }
+            // Request approval
+            if (security.ask === 'on-miss' || security.ask === 'always') {
+                if (!waitForApproval) {
+                    const pending = this.createApprovalRequest(agentId, command, args, cmdStr, options.sessionId, options.requester, false);
+                    return {
+                        allowed: false,
+                        reason: 'Approval required',
+                        requestId: pending.id,
+                    };
+                }
+                const approval = await this.requestApproval(agentId, command, args, cmdStr, options.sessionId, options.requester);
+                if (approval.status === 'approved') {
+                    if (approval.decision === 'allow-always') {
+                        // Add to allowlist
+                        this.addToAllowlist(agentId, command, 'prefix', {
+                            description: 'Auto-added via approval',
+                            addedBy: approval.decidedBy,
+                        });
+                    }
+                    continue;
+                }
+                return {
+                    allowed: false,
+                    reason: approval.status === 'denied' ? 'Approval denied' : 'Approval timeout',
+                };
+            }
+        }
+        return { allowed: true, reason: 'All commands allowed' };
+    }
+    createApprovalRequest(agentId, command, args, fullCommand, sessionId, requester, awaitingDecision = false) {
+        const security = this.getSecurityConfig(agentId);
+        const timeout = security.approvalTimeout || DEFAULT_APPROVAL_TIMEOUT;
+        const request = {
+            id: (0, crypto_1.randomUUID)(),
+            command,
+            args,
+            fullCommand,
+            agentId,
+            sessionId,
+            requester,
+            awaitingDecision,
+            timestamp: new Date(),
+            expiresAt: new Date(Date.now() + timeout),
+            status: 'pending',
+        };
+        this.pendingApprovals.set(request.id, request);
+        this.persistPending();
+        this.emit('approval:request', request);
+        logger_1.logger.info({ requestId: request.id, command, agentId }, 'Approval requested');
+        setTimeout(() => {
+            const existing = this.pendingApprovals.get(request.id);
+            if (existing && existing.status === 'pending' && existing.expiresAt) {
+                if (Date.now() >= existing.expiresAt.getTime()) {
+                    existing.status = 'timeout';
+                    this.pendingApprovals.delete(request.id);
+                    this.persistPending();
+                    this.emit('approval:timeout', existing);
+                }
+            }
+        }, timeout + 500);
+        return request;
+    }
+    /**
+     * Request approval for a command
+     */
+    async requestApproval(agentId, command, args, fullCommand, sessionId, requester) {
+        const request = this.createApprovalRequest(agentId, command, args, fullCommand, sessionId, requester, true);
+        // Wait for decision or timeout
+        const security = this.getSecurityConfig(agentId);
+        const timeout = security.approvalTimeout || DEFAULT_APPROVAL_TIMEOUT;
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                if (request.status === 'pending') {
+                    request.status = 'timeout';
+                    this.pendingApprovals.delete(request.id);
+                    this.persistPending();
+                    this.emit('approval:timeout', request);
+                    clearInterval(poller);
+                    resolve(request);
+                }
+            }, timeout);
+            const poller = setInterval(() => {
+                const decision = this.consumeDecisionForRequest(request.id);
+                if (!decision)
+                    return;
+                this.emit('approval:decision', {
+                    requestId: decision.id,
+                    decision: decision.decision,
+                    decidedBy: decision.decidedBy,
+                });
+            }, 500);
+            // Listen for decision
+            const handler = (decision) => {
+                if (decision.requestId === request.id) {
+                    clearTimeout(timer);
+                    clearInterval(poller);
+                    request.status = decision.decision === 'deny' ? 'denied' : 'approved';
+                    request.decision = decision.decision;
+                    request.decidedBy = decision.decidedBy;
+                    request.decidedAt = new Date();
+                    this.pendingApprovals.delete(request.id);
+                    this.persistPending();
+                    this.removeListener('approval:decision', handler);
+                    resolve(request);
+                }
+            };
+            this.on('approval:decision', handler);
+        });
+    }
+    /**
+     * Make a decision on an approval request
+     */
+    decide(requestId, decision, decidedBy) {
+        const request = this.pendingApprovals.get(requestId);
+        if (!request || request.status !== 'pending') {
+            return false;
+        }
+        this.emit('approval:decision', { requestId, decision, decidedBy });
+        logger_1.logger.info({ requestId, decision, decidedBy }, 'Approval decision made');
+        return true;
+    }
+    /**
+     * Get pending approval requests
+     */
+    getPendingApprovals() {
+        return Array.from(this.pendingApprovals.values());
+    }
+    /**
+     * Get pending approval requests from disk (cross-process)
+     */
+    getPendingApprovalsFromDisk() {
+        const data = this.loadPendingFile();
+        const now = Date.now();
+        const active = data.pending.filter((entry) => !entry.expiresAt || new Date(entry.expiresAt).getTime() > now);
+        if (active.length !== data.pending.length) {
+            this.savePendingFile(active);
+        }
+        return active
+            .map((entry) => ({
+            id: entry.id,
+            command: entry.command,
+            args: entry.args,
+            fullCommand: entry.fullCommand,
+            agentId: entry.agentId,
+            sessionId: entry.sessionId,
+            timestamp: new Date(entry.timestamp),
+            expiresAt: entry.expiresAt ? new Date(entry.expiresAt) : undefined,
+            requester: entry.requester,
+            status: 'pending',
+        }))
+            .filter((req) => !req.expiresAt || req.expiresAt.getTime() > now);
+    }
+    /**
+     * Record a decision to disk (for external approvers like CLI)
+     */
+    recordDecision(requestId, decision, decidedBy) {
+        const pending = this.loadPendingFile();
+        const exists = pending.pending.some((entry) => entry.id === requestId);
+        if (!exists) {
+            return false;
+        }
+        const decisions = this.loadDecisionsFile();
+        const filtered = decisions.decisions.filter((entry) => entry.id !== requestId);
+        filtered.push({
+            id: requestId,
+            decision,
+            decidedBy,
+            decidedAt: new Date().toISOString(),
+        });
+        this.saveDecisionsFile(filtered);
+        return true;
+    }
+    /**
+     * Get pending approval by ID
+     */
+    getPendingApproval(requestId) {
+        return this.pendingApprovals.get(requestId);
+    }
+}
+exports.ExecApprovalsManager = ExecApprovalsManager;
+// =============================================================================
+// TOOL POLICY MANAGER
+// =============================================================================
+class ToolPolicyManager {
+    policies = new Map();
+    /**
+     * Set policy for an agent
+     */
+    setPolicy(agentId, policy) {
+        this.policies.set(agentId, policy);
+    }
+    /**
+     * Get policy for an agent
+     */
+    getPolicy(agentId) {
+        return this.policies.get(agentId);
+    }
+    /**
+     * Expand tool groups in a list
+     */
+    expandGroups(tools) {
+        const expanded = new Set();
+        for (const tool of tools) {
+            if (tool.startsWith('group:')) {
+                const group = exports.TOOL_GROUPS[tool];
+                if (group) {
+                    group.forEach(t => expanded.add(t));
+                }
+            }
+            else {
+                expanded.add(tool);
+            }
+        }
+        return Array.from(expanded);
+    }
+    /**
+     * Get allowed tools for an agent based on profile and policy
+     */
+    getAllowedTools(agentId, profile = 'coding') {
+        const policy = this.policies.get(agentId);
+        // Start with profile tools
+        let allowed = new Set(this.expandGroups(exports.TOOL_PROFILES[profile] || []));
+        // Apply policy
+        if (policy) {
+            if (policy.allow) {
+                allowed = new Set(this.expandGroups(policy.allow));
+            }
+            if (policy.alsoAllow) {
+                for (const tool of this.expandGroups(policy.alsoAllow)) {
+                    allowed.add(tool);
+                }
+            }
+            if (policy.deny) {
+                for (const tool of this.expandGroups(policy.deny)) {
+                    allowed.delete(tool);
+                }
+            }
+        }
+        return Array.from(allowed);
+    }
+    /**
+     * Check if a tool is allowed for an agent
+     */
+    isToolAllowed(agentId, tool, profile = 'coding') {
+        const allowed = this.getAllowedTools(agentId, profile);
+        // Wildcard allows everything
+        if (allowed.includes('*')) {
+            const policy = this.policies.get(agentId);
+            // But still check deny list
+            if (policy?.deny) {
+                return !this.expandGroups(policy.deny).includes(tool);
+            }
+            return true;
+        }
+        return allowed.includes(tool);
+    }
+}
+exports.ToolPolicyManager = ToolPolicyManager;
+class ElevatedPermissions {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            enabled: config.enabled ?? false,
+            allowFrom: config.allowFrom ?? {},
+        };
+    }
+    /**
+     * Check if elevated access is allowed
+     */
+    isAllowed(provider, senderId, channelId, roles) {
+        if (!this.config.enabled) {
+            return false;
+        }
+        const allowList = this.config.allowFrom[provider] || this.config.allowFrom['*'] || [];
+        for (const entry of allowList) {
+            // Check user ID
+            if (entry.startsWith('user:') && entry === `user:${senderId}`) {
+                return true;
+            }
+            // Check channel ID
+            if (entry.startsWith('channel:') && channelId && entry === `channel:${channelId}`) {
+                return true;
+            }
+            // Check role
+            if (entry.startsWith('role:') && roles) {
+                const roleName = entry.slice(5);
+                if (roles.includes(roleName)) {
+                    return true;
+                }
+            }
+            // Check @ prefix (user or role shorthand)
+            if (entry.startsWith('@')) {
+                const name = entry.slice(1);
+                if (senderId === name || roles?.includes(name)) {
+                    return true;
+                }
+            }
+            // Wildcard
+            if (entry === '*') {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Add to allow list
+     */
+    allow(provider, entry) {
+        if (!this.config.allowFrom[provider]) {
+            this.config.allowFrom[provider] = [];
+        }
+        if (!this.config.allowFrom[provider].includes(entry)) {
+            this.config.allowFrom[provider].push(entry);
+        }
+    }
+    /**
+     * Remove from allow list
+     */
+    disallow(provider, entry) {
+        if (this.config.allowFrom[provider]) {
+            this.config.allowFrom[provider] = this.config.allowFrom[provider].filter(e => e !== entry);
+        }
+    }
+    /**
+     * Enable/disable elevated permissions
+     */
+    setEnabled(enabled) {
+        this.config.enabled = enabled;
+    }
+}
+exports.ElevatedPermissions = ElevatedPermissions;
+// =============================================================================
+// EXPORTS
+// =============================================================================
+exports.execApprovals = new ExecApprovalsManager();
+exports.toolPolicies = new ToolPolicyManager();
+exports.elevatedPermissions = new ElevatedPermissions();
+//# sourceMappingURL=index.js.map