@objectstack/core 0.9.0 → 0.9.2

package/dist/security/permission-manager.d.ts

@@ -0,0 +1,96 @@
+import type { Permission, PermissionSet, PermissionAction, ResourceType } from '@objectstack/spec/system';
+import type { ObjectLogger } from '../logger.js';
+/**
+ * Permission Grant
+ * Represents a granted permission at runtime
+ */
+export interface PermissionGrant {
+    permissionId: string;
+    pluginId: string;
+    grantedAt: Date;
+    grantedBy?: string;
+    expiresAt?: Date;
+    conditions?: Record<string, any>;
+}
+/**
+ * Permission Check Result
+ */
+export interface PermissionCheckResult {
+    allowed: boolean;
+    reason?: string;
+    requiredPermission?: string;
+    grantedPermissions?: string[];
+}
+/**
+ * Plugin Permission Manager
+ *
+ * Manages fine-grained permissions for plugin security and access control
+ */
+export declare class PluginPermissionManager {
+    private logger;
+    private permissionSets;
+    private grants;
+    private grantDetails;
+    constructor(logger: ObjectLogger);
+    /**
+     * Register permission requirements for a plugin
+     */
+    registerPermissions(pluginId: string, permissionSet: PermissionSet): void;
+    /**
+     * Grant a permission to a plugin
+     */
+    grantPermission(pluginId: string, permissionId: string, grantedBy?: string, expiresAt?: Date): void;
+    /**
+     * Revoke a permission from a plugin
+     */
+    revokePermission(pluginId: string, permissionId: string): void;
+    /**
+     * Grant all permissions for a plugin
+     */
+    grantAllPermissions(pluginId: string, grantedBy?: string): void;
+    /**
+     * Check if a plugin has a specific permission
+     */
+    hasPermission(pluginId: string, permissionId: string): boolean;
+    /**
+     * Check if plugin can perform an action on a resource
+     */
+    checkAccess(pluginId: string, resource: ResourceType, action: PermissionAction, resourceId?: string): PermissionCheckResult;
+    /**
+     * Get all permissions for a plugin
+     */
+    getPluginPermissions(pluginId: string): Permission[];
+    /**
+     * Get granted permissions for a plugin
+     */
+    getGrantedPermissions(pluginId: string): string[];
+    /**
+     * Get required but not granted permissions
+     */
+    getMissingPermissions(pluginId: string): Permission[];
+    /**
+     * Check if all required permissions are granted
+     */
+    hasAllRequiredPermissions(pluginId: string): boolean;
+    /**
+     * Get permission grant details
+     */
+    getGrantDetails(pluginId: string, permissionId: string): PermissionGrant | undefined;
+    /**
+     * Validate permission against scope constraints
+     */
+    validatePermissionScope(permission: Permission, context: {
+        tenantId?: string;
+        userId?: string;
+        resourceId?: string;
+    }): boolean;
+    /**
+     * Clear all permissions for a plugin
+     */
+    clearPluginPermissions(pluginId: string): void;
+    /**
+     * Shutdown permission manager
+     */
+    shutdown(): void;
+}
+//# sourceMappingURL=permission-manager.d.ts.map

package/dist/security/permission-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-manager.d.ts","sourceRoot":"","sources":["../../src/security/permission-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED;;;;GAIG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,MAAM,CAAe;IAG7B,OAAO,CAAC,cAAc,CAAoC;IAG1D,OAAO,CAAC,MAAM,CAAkC;IAGhD,OAAO,CAAC,YAAY,CAAsC;gBAE9C,MAAM,EAAE,YAAY;IAIhC;;OAEG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,GAAG,IAAI;IASzE;;OAEG;IACH,eAAe,CACb,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,IAAI,GACf,IAAI;IAmCP;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAY9D;;OAEG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAa/D;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO;IAsB9D;;OAEG;IACH,WAAW,CACT,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE,gBAAgB,EACxB,UAAU,CAAC,EAAE,MAAM,GAClB,qBAAqB;IAyDxB;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE;IAKpD;;OAEG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE;IAKjD;;OAEG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE;IAarD;;OAEG;IACH,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIpD;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAKpF;;OAEG;IACH,uBAAuB,CACrB,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GACA,OAAO;IAsBV;;OAEG;IACH,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAe9C;;OAEG;IACH,QAAQ,IAAI,IAAI;CAOjB"}

package/dist/security/permission-manager.js

@@ -0,0 +1,235 @@
+/**
+ * Plugin Permission Manager
+ *
+ * Manages fine-grained permissions for plugin security and access control
+ */
+export class PluginPermissionManager {
+    constructor(logger) {
+        // Plugin permission definitions
+        this.permissionSets = new Map();
+        // Granted permissions (pluginId -> Set of permission IDs)
+        this.grants = new Map();
+        // Permission grant details
+        this.grantDetails = new Map();
+        this.logger = logger.child({ component: 'PermissionManager' });
+    }
+    /**
+     * Register permission requirements for a plugin
+     */
+    registerPermissions(pluginId, permissionSet) {
+        this.permissionSets.set(pluginId, permissionSet);
+        this.logger.info('Permissions registered for plugin', {
+            pluginId,
+            permissionCount: permissionSet.permissions.length
+        });
+    }
+    /**
+     * Grant a permission to a plugin
+     */
+    grantPermission(pluginId, permissionId, grantedBy, expiresAt) {
+        // Verify permission exists in plugin's declared permissions
+        const permissionSet = this.permissionSets.get(pluginId);
+        if (!permissionSet) {
+            throw new Error(`No permissions registered for plugin: ${pluginId}`);
+        }
+        const permission = permissionSet.permissions.find(p => p.id === permissionId);
+        if (!permission) {
+            throw new Error(`Permission ${permissionId} not declared by plugin ${pluginId}`);
+        }
+        // Create grant
+        if (!this.grants.has(pluginId)) {
+            this.grants.set(pluginId, new Set());
+        }
+        this.grants.get(pluginId).add(permissionId);
+        // Store grant details
+        const grantKey = `${pluginId}:${permissionId}`;
+        this.grantDetails.set(grantKey, {
+            permissionId,
+            pluginId,
+            grantedAt: new Date(),
+            grantedBy,
+            expiresAt,
+        });
+        this.logger.info('Permission granted', {
+            pluginId,
+            permissionId,
+            grantedBy
+        });
+    }
+    /**
+     * Revoke a permission from a plugin
+     */
+    revokePermission(pluginId, permissionId) {
+        const grants = this.grants.get(pluginId);
+        if (grants) {
+            grants.delete(permissionId);
+            const grantKey = `${pluginId}:${permissionId}`;
+            this.grantDetails.delete(grantKey);
+            this.logger.info('Permission revoked', { pluginId, permissionId });
+        }
+    }
+    /**
+     * Grant all permissions for a plugin
+     */
+    grantAllPermissions(pluginId, grantedBy) {
+        const permissionSet = this.permissionSets.get(pluginId);
+        if (!permissionSet) {
+            throw new Error(`No permissions registered for plugin: ${pluginId}`);
+        }
+        for (const permission of permissionSet.permissions) {
+            this.grantPermission(pluginId, permission.id, grantedBy);
+        }
+        this.logger.info('All permissions granted', { pluginId, grantedBy });
+    }
+    /**
+     * Check if a plugin has a specific permission
+     */
+    hasPermission(pluginId, permissionId) {
+        const grants = this.grants.get(pluginId);
+        if (!grants) {
+            return false;
+        }
+        // Check if granted
+        if (!grants.has(permissionId)) {
+            return false;
+        }
+        // Check expiration
+        const grantKey = `${pluginId}:${permissionId}`;
+        const grantDetails = this.grantDetails.get(grantKey);
+        if (grantDetails?.expiresAt && grantDetails.expiresAt < new Date()) {
+            this.revokePermission(pluginId, permissionId);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if plugin can perform an action on a resource
+     */
+    checkAccess(pluginId, resource, action, resourceId) {
+        const permissionSet = this.permissionSets.get(pluginId);
+        if (!permissionSet) {
+            return {
+                allowed: false,
+                reason: 'No permissions registered for plugin',
+            };
+        }
+        // Find matching permissions
+        const matchingPermissions = permissionSet.permissions.filter(p => {
+            // Check resource type
+            if (p.resource !== resource) {
+                return false;
+            }
+            // Check action
+            if (!p.actions.includes(action)) {
+                return false;
+            }
+            // Check resource filter if specified
+            if (resourceId && p.filter?.resourceIds) {
+                if (!p.filter.resourceIds.includes(resourceId)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        if (matchingPermissions.length === 0) {
+            return {
+                allowed: false,
+                reason: `No permission found for ${action} on ${resource}`,
+            };
+        }
+        // Check if any matching permission is granted
+        const grantedPermissions = matchingPermissions.filter(p => this.hasPermission(pluginId, p.id));
+        if (grantedPermissions.length === 0) {
+            return {
+                allowed: false,
+                reason: 'Required permissions not granted',
+                requiredPermission: matchingPermissions[0].id,
+            };
+        }
+        return {
+            allowed: true,
+            grantedPermissions: grantedPermissions.map(p => p.id),
+        };
+    }
+    /**
+     * Get all permissions for a plugin
+     */
+    getPluginPermissions(pluginId) {
+        const permissionSet = this.permissionSets.get(pluginId);
+        return permissionSet?.permissions || [];
+    }
+    /**
+     * Get granted permissions for a plugin
+     */
+    getGrantedPermissions(pluginId) {
+        const grants = this.grants.get(pluginId);
+        return grants ? Array.from(grants) : [];
+    }
+    /**
+     * Get required but not granted permissions
+     */
+    getMissingPermissions(pluginId) {
+        const permissionSet = this.permissionSets.get(pluginId);
+        if (!permissionSet) {
+            return [];
+        }
+        const granted = this.grants.get(pluginId) || new Set();
+        return permissionSet.permissions.filter(p => p.required && !granted.has(p.id));
+    }
+    /**
+     * Check if all required permissions are granted
+     */
+    hasAllRequiredPermissions(pluginId) {
+        return this.getMissingPermissions(pluginId).length === 0;
+    }
+    /**
+     * Get permission grant details
+     */
+    getGrantDetails(pluginId, permissionId) {
+        const grantKey = `${pluginId}:${permissionId}`;
+        return this.grantDetails.get(grantKey);
+    }
+    /**
+     * Validate permission against scope constraints
+     */
+    validatePermissionScope(permission, context) {
+        switch (permission.scope) {
+            case 'global':
+                return true;
+            case 'tenant':
+                return !!context.tenantId;
+            case 'user':
+                return !!context.userId;
+            case 'resource':
+                return !!context.resourceId;
+            case 'plugin':
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Clear all permissions for a plugin
+     */
+    clearPluginPermissions(pluginId) {
+        this.permissionSets.delete(pluginId);
+        const grants = this.grants.get(pluginId);
+        if (grants) {
+            for (const permissionId of grants) {
+                const grantKey = `${pluginId}:${permissionId}`;
+                this.grantDetails.delete(grantKey);
+            }
+            this.grants.delete(pluginId);
+        }
+        this.logger.info('All permissions cleared', { pluginId });
+    }
+    /**
+     * Shutdown permission manager
+     */
+    shutdown() {
+        this.permissionSets.clear();
+        this.grants.clear();
+        this.grantDetails.clear();
+        this.logger.info('Permission manager shutdown complete');
+    }
+}

package/dist/security/permission-manager.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=permission-manager.test.d.ts.map

package/dist/security/permission-manager.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-manager.test.d.ts","sourceRoot":"","sources":["../../src/security/permission-manager.test.ts"],"names":[],"mappings":""}

package/dist/security/permission-manager.test.js

@@ -0,0 +1,220 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PluginPermissionManager } from './permission-manager.js';
+import { createLogger } from '../logger.js';
+describe('PluginPermissionManager', () => {
+    let manager;
+    let logger;
+    beforeEach(() => {
+        logger = createLogger({ level: 'silent' });
+        manager = new PluginPermissionManager(logger);
+    });
+    describe('registerPermissions', () => {
+        it('should register permissions for a plugin', () => {
+            const permissionSet = {
+                permissions: [
+                    {
+                        id: 'read-data',
+                        resource: 'data.object',
+                        actions: ['read'],
+                        scope: 'plugin',
+                        description: 'Read object data',
+                        required: true,
+                    },
+                ],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            const permissions = manager.getPluginPermissions('test-plugin');
+            expect(permissions).toHaveLength(1);
+            expect(permissions[0].id).toBe('read-data');
+        });
+    });
+    describe('grantPermission', () => {
+        it('should grant a permission to a plugin', () => {
+            const permissionSet = {
+                permissions: [
+                    {
+                        id: 'read-data',
+                        resource: 'data.object',
+                        actions: ['read'],
+                        scope: 'plugin',
+                        description: 'Read object data',
+                        required: true,
+                    },
+                ],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            manager.grantPermission('test-plugin', 'read-data');
+            expect(manager.hasPermission('test-plugin', 'read-data')).toBe(true);
+        });
+        it('should throw error for non-existent permission', () => {
+            const permissionSet = {
+                permissions: [],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            expect(() => {
+                manager.grantPermission('test-plugin', 'invalid-permission');
+            }).toThrow();
+        });
+    });
+    describe('revokePermission', () => {
+        it('should revoke a permission from a plugin', () => {
+            const permissionSet = {
+                permissions: [
+                    {
+                        id: 'read-data',
+                        resource: 'data.object',
+                        actions: ['read'],
+                        scope: 'plugin',
+                        description: 'Read object data',
+                        required: true,
+                    },
+                ],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            manager.grantPermission('test-plugin', 'read-data');
+            manager.revokePermission('test-plugin', 'read-data');
+            expect(manager.hasPermission('test-plugin', 'read-data')).toBe(false);
+        });
+    });
+    describe('checkAccess', () => {
+        it('should allow access when permission is granted', () => {
+            const permissionSet = {
+                permissions: [
+                    {
+                        id: 'read-data',
+                        resource: 'data.object',
+                        actions: ['read'],
+                        scope: 'plugin',
+                        description: 'Read object data',
+                        required: true,
+                    },
+                ],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            manager.grantPermission('test-plugin', 'read-data');
+            const result = manager.checkAccess('test-plugin', 'data.object', 'read');
+            expect(result.allowed).toBe(true);
+        });
+        it('should deny access when permission is not granted', () => {
+            const permissionSet = {
+                permissions: [
+                    {
+                        id: 'read-data',
+                        resource: 'data.object',
+                        actions: ['read'],
+                        scope: 'plugin',
+                        description: 'Read object data',
+                        required: true,
+                    },
+                ],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            const result = manager.checkAccess('test-plugin', 'data.object', 'read');
+            expect(result.allowed).toBe(false);
+        });
+        it('should deny access when permission does not exist', () => {
+            const permissionSet = {
+                permissions: [],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            const result = manager.checkAccess('test-plugin', 'data.object', 'read');
+            expect(result.allowed).toBe(false);
+        });
+    });
+    describe('getMissingPermissions', () => {
+        it('should return missing required permissions', () => {
+            const permissionSet = {
+                permissions: [
+                    {
+                        id: 'read-data',
+                        resource: 'data.object',
+                        actions: ['read'],
+                        scope: 'plugin',
+                        description: 'Read object data',
+                        required: true,
+                    },
+                    {
+                        id: 'write-data',
+                        resource: 'data.object',
+                        actions: ['create', 'update'],
+                        scope: 'plugin',
+                        description: 'Write object data',
+                        required: true,
+                    },
+                ],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            manager.grantPermission('test-plugin', 'read-data');
+            const missing = manager.getMissingPermissions('test-plugin');
+            expect(missing).toHaveLength(1);
+            expect(missing[0].id).toBe('write-data');
+        });
+    });
+    describe('hasAllRequiredPermissions', () => {
+        it('should return true when all required permissions are granted', () => {
+            const permissionSet = {
+                permissions: [
+                    {
+                        id: 'read-data',
+                        resource: 'data.object',
+                        actions: ['read'],
+                        scope: 'plugin',
+                        description: 'Read object data',
+                        required: true,
+                    },
+                ],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            manager.grantPermission('test-plugin', 'read-data');
+            expect(manager.hasAllRequiredPermissions('test-plugin')).toBe(true);
+        });
+        it('should return false when required permissions are missing', () => {
+            const permissionSet = {
+                permissions: [
+                    {
+                        id: 'read-data',
+                        resource: 'data.object',
+                        actions: ['read'],
+                        scope: 'plugin',
+                        description: 'Read object data',
+                        required: true,
+                    },
+                ],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            expect(manager.hasAllRequiredPermissions('test-plugin')).toBe(false);
+        });
+    });
+    describe('clearPluginPermissions', () => {
+        it('should clear all permissions for a plugin', () => {
+            const permissionSet = {
+                permissions: [
+                    {
+                        id: 'read-data',
+                        resource: 'data.object',
+                        actions: ['read'],
+                        scope: 'plugin',
+                        description: 'Read object data',
+                        required: true,
+                    },
+                ],
+                defaultGrant: 'prompt',
+            };
+            manager.registerPermissions('test-plugin', permissionSet);
+            manager.grantPermission('test-plugin', 'read-data');
+            manager.clearPluginPermissions('test-plugin');
+            expect(manager.getPluginPermissions('test-plugin')).toHaveLength(0);
+            expect(manager.getGrantedPermissions('test-plugin')).toHaveLength(0);
+        });
+    });
+});

package/dist/security/plugin-signature-verifier.js

@@ -2,9 +2,9 @@
 let cryptoModule = null;
 if (typeof globalThis.window === 'undefined') {
     try {
-        // Dynamic import for Node.js crypto module
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        cryptoModule = require('crypto');
+        // Dynamic import for Node.js crypto module (using eval to avoid bundling issues)
+        // @ts-ignore - dynamic require for Node.js
+        cryptoModule = eval('require("crypto")');
     }
     catch {
         // Crypto module not available (e.g., browser environment)

package/dist/security/sandbox-runtime.d.ts

@@ -0,0 +1,115 @@
+import type { SandboxConfig } from '@objectstack/spec/system';
+import type { ObjectLogger } from '../logger.js';
+/**
+ * Resource Usage Statistics
+ */
+export interface ResourceUsage {
+    memory: {
+        current: number;
+        peak: number;
+        limit?: number;
+    };
+    cpu: {
+        current: number;
+        average: number;
+        limit?: number;
+    };
+    connections: {
+        current: number;
+        limit?: number;
+    };
+}
+/**
+ * Sandbox Execution Context
+ * Represents an isolated execution environment for a plugin
+ */
+export interface SandboxContext {
+    pluginId: string;
+    config: SandboxConfig;
+    startTime: Date;
+    resourceUsage: ResourceUsage;
+}
+/**
+ * Plugin Sandbox Runtime
+ *
+ * Provides isolated execution environments for plugins with resource limits
+ * and access controls
+ */
+export declare class PluginSandboxRuntime {
+    private logger;
+    private sandboxes;
+    private monitoringIntervals;
+    constructor(logger: ObjectLogger);
+    /**
+     * Create a sandbox for a plugin
+     */
+    createSandbox(pluginId: string, config: SandboxConfig): SandboxContext;
+    /**
+     * Destroy a sandbox
+     */
+    destroySandbox(pluginId: string): void;
+    /**
+     * Check if resource access is allowed
+     */
+    checkResourceAccess(pluginId: string, resourceType: 'file' | 'network' | 'process' | 'env', resourcePath?: string): {
+        allowed: boolean;
+        reason?: string;
+    };
+    /**
+     * Check file system access
+     * WARNING: Uses simple prefix matching. For production, use proper path
+     * resolution with path.resolve() and path.normalize() to prevent traversal.
+     */
+    private checkFileAccess;
+    /**
+     * Check network access
+     * WARNING: Uses simple string matching. For production, use proper URL
+     * parsing with new URL() and check hostname property.
+     */
+    private checkNetworkAccess;
+    /**
+     * Check process spawning access
+     */
+    private checkProcessAccess;
+    /**
+     * Check environment variable access
+     */
+    private checkEnvAccess;
+    /**
+     * Check resource limits
+     */
+    checkResourceLimits(pluginId: string): {
+        withinLimits: boolean;
+        violations: string[];
+    };
+    /**
+     * Get resource usage for a plugin
+     */
+    getResourceUsage(pluginId: string): ResourceUsage | undefined;
+    /**
+     * Start monitoring resource usage
+     */
+    private startResourceMonitoring;
+    /**
+     * Stop monitoring resource usage
+     */
+    private stopResourceMonitoring;
+    /**
+     * Update resource usage statistics
+     *
+     * NOTE: Currently uses global process.memoryUsage() which tracks the entire
+     * Node.js process, not individual plugins. For production, implement proper
+     * per-plugin tracking using V8 heap snapshots or allocation tracking at
+     * plugin boundaries.
+     */
+    private updateResourceUsage;
+    /**
+     * Get all active sandboxes
+     */
+    getAllSandboxes(): Map<string, SandboxContext>;
+    /**
+     * Shutdown sandbox runtime
+     */
+    shutdown(): void;
+}
+//# sourceMappingURL=sandbox-runtime.d.ts.map