@allternit/ix 0.1.0 → 0.1.1

package/dist/runtime/capsule-runtime.js.bak

@@ -1,563 +0,0 @@
-/**
- * IX Capsule Runtime
- *
- * Integration with P3.9 MCP Apps capsule infrastructure for sandboxed
- * execution of A2R-IX UI capsules.
- */
-import { applyPatchToStore } from '../state/patch';
-/**
- * GAP-63: System metrics collector using Node.js APIs
- */
-class MetricsCollector {
-    startUsage = null;
-    startTime;
-    networkStats = {
-        requestCount: 0,
-        successCount: 0,
-        errorCount: 0,
-        bytesSent: 0,
-        bytesReceived: 0,
-        responseTimes: [],
-    };
-    constructor() {
-        this.startTime = Date.now();
-        // Capture initial CPU usage if available (Node.js environment)
-        if (typeof process !== 'undefined' && process.cpuUsage) {
-            this.startUsage = process.cpuUsage();
-        }
-    }
-    /**
-     * Collect current CPU metrics
-     */
-    collectCPU() {
-        if (typeof process === 'undefined' || !process.cpuUsage) {
-            return {
-                userTime: 0,
-                systemTime: 0,
-                totalTime: 0,
-                usagePercent: 0,
-            };
-        }
-        const currentUsage = process.cpuUsage(this.startUsage || undefined);
-        const userTime = currentUsage.user / 1000; // Convert microseconds to milliseconds
-        const systemTime = currentUsage.system / 1000;
-        const totalTime = userTime + systemTime;
-        // Calculate percentage based on elapsed time
-        const elapsedMs = Date.now() - this.startTime;
-        const usagePercent = elapsedMs > 0 ? (totalTime / elapsedMs) * 100 : 0;
-        return {
-            userTime,
-            systemTime,
-            totalTime,
-            usagePercent: Math.min(usagePercent, 100), // Cap at 100%
-        };
-    }
-    /**
-     * Collect current memory metrics
-     */
-    collectMemory() {
-        if (typeof process === 'undefined' || !process.memoryUsage) {
-            return {
-                heapUsed: 0,
-                heapTotal: 0,
-                external: 0,
-                rss: 0,
-                arrayBuffers: 0,
-            };
-        }
-        const usage = process.memoryUsage();
-        return {
-            heapUsed: usage.heapUsed,
-            heapTotal: usage.heapTotal,
-            external: usage.external || 0,
-            rss: usage.rss,
-            arrayBuffers: usage.arrayBuffers || 0,
-        };
-    }
-    /**
-     * Record a network request
-     */
-    recordRequest(bytesSent) {
-        this.networkStats.requestCount++;
-        this.networkStats.bytesSent += bytesSent;
-    }
-    /**
-     * Record a successful response
-     */
-    recordResponse(bytesReceived, responseTime) {
-        this.networkStats.successCount++;
-        this.networkStats.bytesReceived += bytesReceived;
-        this.networkStats.responseTimes.push(responseTime);
-        // Keep only last 100 response times for average calculation
-        if (this.networkStats.responseTimes.length > 100) {
-            this.networkStats.responseTimes.shift();
-        }
-    }
-    /**
-     * Record a network error
-     */
-    recordNetworkError() {
-        this.networkStats.errorCount++;
-    }
-    /**
-     * Collect network metrics
-     */
-    collectNetwork() {
-        const avgResponseTime = this.networkStats.responseTimes.length > 0
-            ? this.networkStats.responseTimes.reduce((a, b) => a + b, 0) / this.networkStats.responseTimes.length
-            : 0;
-        return {
-            requestCount: this.networkStats.requestCount,
-            successCount: this.networkStats.successCount,
-            errorCount: this.networkStats.errorCount,
-            bytesSent: this.networkStats.bytesSent,
-            bytesReceived: this.networkStats.bytesReceived,
-            avgResponseTime,
-        };
-    }
-    /**
-     * Get average response time
-     */
-    getAverageResponseTime() {
-        if (this.networkStats.responseTimes.length === 0)
-            return 0;
-        return this.networkStats.responseTimes.reduce((a, b) => a + b, 0) / this.networkStats.responseTimes.length;
-    }
-}
-/**
- * Create IX Capsule
- */
-export function createIXCapsule(config) {
-    let active = true;
-    let currentUI = config.ui;
-    const stateStore = config.stateStore;
-    const subscribers = new Set();
-    const metricsCollector = new MetricsCollector();
-    const metrics = {
-        renderCount: 0,
-        actionCount: 0,
-        stateUpdateCount: 0,
-        errorCount: 0,
-        startTime: Date.now(),
-        lastActivity: Date.now(),
-    };
-    /**
-     * Emit event to subscribers
-     */
-    function emit(event) {
-        if (!active)
-            return;
-        metrics.lastActivity = Date.now();
-        subscribers.forEach((cb) => {
-            try {
-                cb(event);
-            }
-            catch (error) {
-                console.error('IX Capsule subscriber error:', error);
-            }
-        });
-        config.onEvent?.(event);
-    }
-    /**
-     * Check policy gates
-     */
-    async function checkPolicies(type, context) {
-        if (!config.policyGates || config.policyGates.length === 0) {
-            return { allowed: true };
-        }
-        const fullContext = { ...context, timestamp: Date.now() };
-        for (const gate of config.policyGates) {
-            const result = await gate.check(type, fullContext);
-            if (!result.allowed) {
-                return result;
-            }
-        }
-        return { allowed: true };
-    }
-    /**
-     * Get current UI
-     */
-    function getUI() {
-        return currentUI;
-    }
-    /**
-     * Update UI definition
-     */
-    function updateUI(ui) {
-        if (!active) {
-            throw new Error(`Capsule ${config.id} is not active`);
-        }
-        currentUI = ui;
-        metrics.renderCount++;
-        emit({
-            type: 'lifecycle',
-            capsuleId: config.id,
-            lifecycle: 'update',
-        });
-    }
-    /**
-     * Apply state patch
-     */
-    function applyPatch(patch) {
-        if (!active)
-            return;
-        const result = applyPatchToStore(stateStore, patch);
-        if (result.success) {
-            metrics.stateUpdateCount++;
-            // Emit state change events for affected paths
-            patch.forEach((op) => {
-                if (op.op !== 'test' && op.op !== 'remove') {
-                    const path = op.path.slice(1).replace(/\//g, '.');
-                    const value = stateStore.get(path);
-                    emit({
-                        type: 'state-change',
-                        capsuleId: config.id,
-                        path,
-                        value,
-                    });
-                    config.onStateChange?.(path, value);
-                }
-            });
-        }
-        else {
-            metrics.errorCount++;
-            emit({
-                type: 'error',
-                capsuleId: config.id,
-                error: new Error(result.error || 'Patch failed'),
-            });
-        }
-    }
-    /**
-     * Get state value
-     */
-    function getState(path) {
-        return stateStore.get(path);
-    }
-    /**
-     * Set state value
-     */
-    function setState(path, value) {
-        if (!active)
-            return;
-        stateStore.set(path, value);
-        metrics.stateUpdateCount++;
-        emit({
-            type: 'state-change',
-            capsuleId: config.id,
-            path,
-            value,
-        });
-        config.onStateChange?.(path, value);
-    }
-    /**
-     * Dispatch action with policy checking
-     */
-    async function dispatch(actionId, params) {
-        if (!active) {
-            throw new Error(`Capsule ${config.id} is not active`);
-        }
-        // Find action definition
-        const action = currentUI.actions.find((a) => a.id === actionId);
-        if (!action) {
-            const error = new Error(`Action not found: ${actionId}`);
-            emit({
-                type: 'error',
-                capsuleId: config.id,
-                error,
-            });
-            throw error;
-        }
-        // Check policies
-        const policyResult = await checkPolicies('action', {
-            capsuleId: config.id,
-            actionId,
-            params,
-            state: stateStore.snapshot(),
-        });
-        if (!policyResult.allowed) {
-            emit({
-                type: 'error',
-                capsuleId: config.id,
-                error: new Error(`Policy denied: ${policyResult.reason}`),
-            });
-            return false;
-        }
-        metrics.actionCount++;
-        emit({
-            type: 'action',
-            capsuleId: config.id,
-            action: actionId,
-            params,
-        });
-        return true;
-    }
-    /**
-     * Subscribe to events
-     */
-    function subscribe(callback) {
-        subscribers.add(callback);
-        return () => {
-            subscribers.delete(callback);
-        };
-    }
-    /**
-     * Destroy capsule
-     */
-    function destroy() {
-        if (!active)
-            return;
-        // Emit unmount event before marking inactive
-        emit({
-            type: 'lifecycle',
-            capsuleId: config.id,
-            lifecycle: 'unmount',
-        });
-        active = false;
-        subscribers.clear();
-        config.onDestroy?.();
-    }
-    /**
-     * Check if active
-     */
-    function isActive() {
-        return active;
-    }
-    /**
-     * GAP-62: Get capsule metrics
-     * Returns comprehensive metrics including CPU, memory, and network stats
-     */
-    function getMetrics() {
-        const now = Date.now();
-        return {
-            renderCount: metrics.renderCount,
-            actionCount: metrics.actionCount,
-            stateUpdateCount: metrics.stateUpdateCount,
-            errorCount: metrics.errorCount,
-            startTime: metrics.startTime,
-            lastActivity: metrics.lastActivity,
-            uptime: now - metrics.startTime,
-            // GAP-63: Collect system metrics
-            cpu: metricsCollector.collectCPU(),
-            memory: metricsCollector.collectMemory(),
-            network: metricsCollector.collectNetwork(),
-        };
-    }
-    // Initialize
-    emit({
-        type: 'lifecycle',
-        capsuleId: config.id,
-        lifecycle: 'mount',
-    });
-    return {
-        id: config.id,
-        getUI,
-        updateUI,
-        applyPatch,
-        getState,
-        setState,
-        dispatch,
-        subscribe,
-        destroy,
-        isActive,
-        getMetrics,
-    };
-}
-/**
- * IX Capsule Registry
- */
-export class IXCapsuleRegistry {
-    capsules = new Map();
-    defaultPolicyGates = [];
-    /**
-     * Set default policy gates for all capsules
-     */
-    setDefaultPolicyGates(gates) {
-        this.defaultPolicyGates = gates;
-    }
-    /**
-     * Create and register capsule
-     */
-    create(config) {
-        const capsule = createIXCapsule({
-            ...config,
-            policyGates: config.policyGates ?? this.defaultPolicyGates,
-        });
-        this.capsules.set(config.id, capsule);
-        return capsule;
-    }
-    /**
-     * Get capsule by ID
-     */
-    get(id) {
-        return this.capsules.get(id);
-    }
-    /**
-     * Check if capsule exists
-     */
-    has(id) {
-        return this.capsules.has(id);
-    }
-    /**
-     * Remove capsule
-     */
-    remove(id) {
-        const capsule = this.capsules.get(id);
-        if (capsule) {
-            capsule.destroy();
-            this.capsules.delete(id);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * List all capsules
-     */
-    list() {
-        return Array.from(this.capsules.values());
-    }
-    /**
-     * Get active capsules
-     */
-    getActive() {
-        return this.list().filter((c) => c.isActive());
-    }
-    /**
-     * Broadcast patch to all capsules
-     */
-    broadcastPatch(patch) {
-        this.capsules.forEach((capsule) => {
-            capsule.applyPatch(patch);
-        });
-    }
-    /**
-     * Destroy all capsules
-     */
-    clear() {
-        this.capsules.forEach((capsule) => capsule.destroy());
-        this.capsules.clear();
-    }
-    /**
-     * GAP-62/64: Get metrics for all capsules
-     * Returns aggregated metrics for all registered capsules
-     */
-    getMetrics() {
-        const metrics = {};
-        for (const [id, capsule] of this.capsules) {
-            if (capsule.isActive()) {
-                metrics[id] = capsule.getMetrics();
-            }
-        }
-        return metrics;
-    }
-    /**
-     * GAP-64: Get aggregated metrics across all capsules
-     * Returns summary statistics for the entire registry
-     */
-    getAggregatedMetrics() {
-        const allMetrics = Object.values(this.getMetrics());
-        if (allMetrics.length === 0) {
-            return {
-                totalCapsules: 0,
-                activeCapsules: 0,
-                totalRenders: 0,
-                totalActions: 0,
-                totalStateUpdates: 0,
-                totalErrors: 0,
-                avgUptime: 0,
-                totalMemoryUsed: 0,
-                avgCpuUsage: 0,
-            };
-        }
-        const now = Date.now();
-        const activeCapsules = allMetrics.filter(m => m.uptime > 0);
-        const totalRenders = allMetrics.reduce((sum, m) => sum + m.renderCount, 0);
-        const totalActions = allMetrics.reduce((sum, m) => sum + m.actionCount, 0);
-        const totalStateUpdates = allMetrics.reduce((sum, m) => sum + m.stateUpdateCount, 0);
-        const totalErrors = allMetrics.reduce((sum, m) => sum + m.errorCount, 0);
-        const avgUptime = activeCapsules.reduce((sum, m) => sum + m.uptime, 0) / activeCapsules.length;
-        const totalMemoryUsed = activeCapsules.reduce((sum, m) => sum + (m.memory?.heapUsed || 0), 0);
-        const avgCpuUsage = activeCapsules.length > 0
-            ? activeCapsules.reduce((sum, m) => sum + (m.cpu?.usagePercent || 0), 0) / activeCapsules.length
-            : 0;
-        return {
-            totalCapsules: this.capsules.size,
-            activeCapsules: activeCapsules.length,
-            totalRenders,
-            totalActions,
-            totalStateUpdates,
-            totalErrors,
-            avgUptime,
-            totalMemoryUsed,
-            avgCpuUsage,
-        };
-    }
-    /**
-     * GAP-64: Export metrics for external monitoring systems
-     * Returns metrics in a format suitable for Prometheus, DataDog, etc.
-     */
-    exportMetrics() {
-        const aggregated = this.getAggregatedMetrics();
-        const individual = this.getMetrics();
-        return {
-            timestamp: Date.now(),
-            summary: aggregated,
-            capsules: individual,
-            // Prometheus-style metrics
-            prometheus: this.toPrometheusFormat(individual, aggregated),
-        };
-    }
-    /**
-     * Convert metrics to Prometheus format
-     */
-    toPrometheusFormat(individual, aggregated) {
-        const lines = [];
-        // Help and type annotations
-        lines.push('# HELP ix_capsule_renders_total Total number of renders per capsule');
-        lines.push('# TYPE ix_capsule_renders_total counter');
-        for (const [id, m] of Object.entries(individual)) {
-            lines.push(`ix_capsule_renders_total{capsule_id="${id}"} ${m.renderCount}`);
-        }
-        lines.push('');
-        lines.push('# HELP ix_capsule_actions_total Total number of actions per capsule');
-        lines.push('# TYPE ix_capsule_actions_total counter');
-        for (const [id, m] of Object.entries(individual)) {
-            lines.push(`ix_capsule_actions_total{capsule_id="${id}"} ${m.actionCount}`);
-        }
-        lines.push('');
-        lines.push('# HELP ix_capsule_errors_total Total number of errors per capsule');
-        lines.push('# TYPE ix_capsule_errors_total counter');
-        for (const [id, m] of Object.entries(individual)) {
-            lines.push(`ix_capsule_errors_total{capsule_id="${id}"} ${m.errorCount}`);
-        }
-        lines.push('');
-        lines.push('# HELP ix_capsule_memory_bytes Memory usage per capsule');
-        lines.push('# TYPE ix_capsule_memory_bytes gauge');
-        for (const [id, m] of Object.entries(individual)) {
-            if (m.memory) {
-                lines.push(`ix_capsule_memory_bytes{capsule_id="${id}",type="heap_used"} ${m.memory.heapUsed}`);
-                lines.push(`ix_capsule_memory_bytes{capsule_id="${id}",type="heap_total"} ${m.memory.heapTotal}`);
-                lines.push(`ix_capsule_memory_bytes{capsule_id="${id}",type="rss"} ${m.memory.rss}`);
-            }
-        }
-        lines.push('');
-        lines.push('# HELP ix_capsule_cpu_usage_percent CPU usage percentage per capsule');
-        lines.push('# TYPE ix_capsule_cpu_usage_percent gauge');
-        for (const [id, m] of Object.entries(individual)) {
-            if (m.cpu) {
-                lines.push(`ix_capsule_cpu_usage_percent{capsule_id="${id}"} ${m.cpu.usagePercent.toFixed(2)}`);
-            }
-        }
-        lines.push('');
-        lines.push('# HELP ix_registry_capsules_total Total number of capsules in registry');
-        lines.push('# TYPE ix_registry_capsules_total gauge');
-        lines.push(`ix_registry_capsules_total{state="active"} ${aggregated.activeCapsules}`);
-        lines.push(`ix_registry_capsules_total{state="total"} ${aggregated.totalCapsules}`);
-        return lines.join('\n');
-    }
-}
-/**
- * Global capsule registry
- */
-export const globalCapsuleRegistry = new IXCapsuleRegistry();
-//# sourceMappingURL=capsule-runtime.js.map

package/dist/runtime/policy-gates.d.ts.bak

@@ -1,116 +0,0 @@
-/**
- * Policy Gates
- *
- * Security controls for IX capsule execution.
- *
- * Policy gates enforce security boundaries for:
- * - Action execution (rate limiting, allowlists)
- * - State changes (validation, sanitization)
- * - Rendering (component restrictions, prop filtering)
- */
-export interface PolicyContext {
-    /** Capsule ID */
-    capsuleId: string;
-    /** Action being performed */
-    actionId?: string;
-    /** Action parameters */
-    params?: Record<string, unknown>;
-    /** State snapshot */
-    state?: Record<string, unknown>;
-    /** Component being rendered */
-    component?: string;
-    /** Props being passed */
-    props?: Record<string, unknown>;
-    /** Timestamp */
-    timestamp: number;
-    /** User/agent identifier */
-    agentId?: string;
-}
-export interface PolicyResult {
-    allowed: boolean;
-    reason?: string;
-    /** Modified context (for sanitization) */
-    context?: PolicyContext;
-    /** Audit log entry */
-    audit?: Record<string, unknown>;
-}
-export interface PolicyGate {
-    name: string;
-    check: (type: 'action' | 'state-change' | 'render', context: PolicyContext) => Promise<PolicyResult> | PolicyResult;
-}
-/**
- * Rate Limiting Policy Gate
- *
- * Limits action execution rate per capsule.
- */
-export declare function createRateLimitGate(options: {
-    maxActionsPerMinute: number;
-    burstSize?: number;
-    windowMs?: number;
-}): PolicyGate;
-/**
- * Action Allowlist Policy Gate
- *
- * Only allows specific actions to execute.
- */
-export declare function createActionAllowlistGate(allowedActions: string[]): PolicyGate;
-/**
- * Component Restrictions Policy Gate
- *
- * Restricts which components can be rendered.
- */
-export declare function createComponentRestrictionsGate(options: {
-    allowedComponents?: string[];
-    blockedComponents?: string[];
-    maxDepth?: number;
-}): PolicyGate;
-/**
- * State Validation Policy Gate
- *
- * Validates state changes against schema.
- */
-export declare function createStateValidationGate(schema: {
-    [path: string]: {
-        type: 'string' | 'number' | 'boolean' | 'array' | 'object';
-        required?: boolean;
-        validate?: (value: unknown) => boolean | string;
-    };
-}): PolicyGate;
-/**
- * Prop Sanitization Policy Gate
- *
- * Sanitizes component props to prevent XSS and injection attacks.
- */
-export declare function createPropSanitizationGate(options: {
-    allowHTML?: boolean;
-    allowedTags?: string[];
-    allowedAttributes?: string[];
-}): PolicyGate;
-/**
- * Resource Limiting Policy Gate
- *
- * Enforces resource limits on capsules.
- */
-export declare function createResourceLimitGate(options: {
-    maxStateSize?: number;
-    maxComponents?: number;
-    maxActions?: number;
-}): PolicyGate;
-/**
- * Audit Logging Policy Gate
- *
- * Logs all policy decisions for audit purposes.
- */
-export declare function createAuditLogGate(options: {
-    logFn: (entry: Record<string, unknown>) => void;
-    logAllowed?: boolean;
-}): PolicyGate;
-/**
- * Compose multiple policy gates
- */
-export declare function composePolicyGates(...gates: PolicyGate[]): PolicyGate;
-/**
- * Create default security policy gates
- */
-export declare function createDefaultPolicyGates(): PolicyGate[];
-//# sourceMappingURL=policy-gates.d.ts.map