@allternit/ix 0.1.0 → 0.1.1

package/dist/runtime/policy-gates.js.bak

@@ -1,317 +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)
- */
-/**
- * Rate Limiting Policy Gate
- *
- * Limits action execution rate per capsule.
- */
-export function createRateLimitGate(options) {
-    const { maxActionsPerMinute, burstSize = maxActionsPerMinute, windowMs = 60000 } = options;
-    const actionLog = new Map();
-    return {
-        name: 'rate-limit',
-        check: (_type, context) => {
-            if (_type !== 'action')
-                return { allowed: true };
-            const now = Date.now();
-            const log = actionLog.get(context.capsuleId) || [];
-            // Remove old entries outside window
-            const validLog = log.filter((ts) => now - ts < windowMs);
-            // Check burst limit
-            if (validLog.length >= burstSize) {
-                return {
-                    allowed: false,
-                    reason: `Rate limit exceeded: ${maxActionsPerMinute} actions per minute`,
-                };
-            }
-            // Record action
-            validLog.push(now);
-            actionLog.set(context.capsuleId, validLog);
-            return { allowed: true };
-        },
-    };
-}
-/**
- * Action Allowlist Policy Gate
- *
- * Only allows specific actions to execute.
- */
-export function createActionAllowlistGate(allowedActions) {
-    const allowedSet = new Set(allowedActions);
-    return {
-        name: 'action-allowlist',
-        check: (type, context) => {
-            if (type !== 'action')
-                return { allowed: true };
-            if (!context.actionId || !allowedSet.has(context.actionId)) {
-                return {
-                    allowed: false,
-                    reason: `Action '${context.actionId}' is not in allowlist`,
-                };
-            }
-            return { allowed: true };
-        },
-    };
-}
-/**
- * Component Restrictions Policy Gate
- *
- * Restricts which components can be rendered.
- */
-export function createComponentRestrictionsGate(options) {
-    const { allowedComponents, blockedComponents = [], maxDepth = 10 } = options;
-    const allowedSet = allowedComponents ? new Set(allowedComponents) : null;
-    const blockedSet = new Set(blockedComponents);
-    return {
-        name: 'component-restrictions',
-        check: (type, context) => {
-            if (type !== 'render')
-                return { allowed: true };
-            if (!context.component)
-                return { allowed: true };
-            // Check blocked
-            if (blockedSet.has(context.component)) {
-                return {
-                    allowed: false,
-                    reason: `Component '${context.component}' is blocked`,
-                };
-            }
-            // Check allowed
-            if (allowedSet && !allowedSet.has(context.component)) {
-                return {
-                    allowed: false,
-                    reason: `Component '${context.component}' is not in allowlist`,
-                };
-            }
-            return { allowed: true };
-        },
-    };
-}
-/**
- * State Validation Policy Gate
- *
- * Validates state changes against schema.
- */
-export function createStateValidationGate(schema) {
-    return {
-        name: 'state-validation',
-        check: (type, context) => {
-            if (type !== 'state-change')
-                return { allowed: true };
-            // This would need the actual path and value being changed
-            // For now, validate entire state snapshot
-            if (!context.state)
-                return { allowed: true };
-            for (const [path, rules] of Object.entries(schema)) {
-                const value = getPathValue(context.state, path);
-                // Check required
-                if (rules.required && (value === undefined || value === null)) {
-                    return {
-                        allowed: false,
-                        reason: `State path '${path}' is required`,
-                    };
-                }
-                // Skip if not required and undefined
-                if (!rules.required && (value === undefined || value === null)) {
-                    continue;
-                }
-                // Check type
-                if (rules.type) {
-                    const actualType = getValueType(value);
-                    if (actualType !== rules.type) {
-                        return {
-                            allowed: false,
-                            reason: `State path '${path}' must be ${rules.type}, got ${actualType}`,
-                        };
-                    }
-                }
-                // Run custom validation
-                if (rules.validate) {
-                    const result = rules.validate(value);
-                    if (result !== true) {
-                        return {
-                            allowed: false,
-                            reason: typeof result === 'string' ? result : `Validation failed for '${path}'`,
-                        };
-                    }
-                }
-            }
-            return { allowed: true };
-        },
-    };
-}
-/**
- * Prop Sanitization Policy Gate
- *
- * Sanitizes component props to prevent XSS and injection attacks.
- */
-export function createPropSanitizationGate(options) {
-    const { allowHTML = false, allowedTags = [], allowedAttributes = [] } = options;
-    return {
-        name: 'prop-sanitization',
-        check: (type, context) => {
-            if (type !== 'render' || !context.props)
-                return { allowed: true };
-            const sanitizedProps = { ...context.props };
-            let modified = false;
-            for (const [key, value] of Object.entries(context.props)) {
-                // Sanitize string values
-                if (typeof value === 'string') {
-                    // Remove script tags and event handlers
-                    let sanitized = value;
-                    if (!allowHTML) {
-                        // Strip all HTML
-                        sanitized = sanitized.replace(/<[^>]*>/g, '');
-                    }
-                    else {
-                        // Remove script tags and their content completely
-                        sanitized = sanitized.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '');
-                        // Allow only specific tags
-                        const tagRegex = /<\/?([a-z][a-z0-9]*)[^>]*>/gi;
-                        sanitized = sanitized.replace(tagRegex, (match, tag) => {
-                            return allowedTags.includes(tag.toLowerCase()) ? match : '';
-                        });
-                        // Remove event handlers
-                        sanitized = sanitized.replace(/on\w+\s*=/gi, '');
-                        // Remove javascript: URLs
-                        sanitized = sanitized.replace(/javascript:/gi, '');
-                    }
-                    if (sanitized !== value) {
-                        sanitizedProps[key] = sanitized;
-                        modified = true;
-                    }
-                }
-                // Block dangerous props
-                if (key.startsWith('on') && typeof value === 'string') {
-                    // Block string-based event handlers
-                    delete sanitizedProps[key];
-                    modified = true;
-                }
-            }
-            return {
-                allowed: true,
-                context: modified ? { ...context, props: sanitizedProps } : context,
-            };
-        },
-    };
-}
-/**
- * Resource Limiting Policy Gate
- *
- * Enforces resource limits on capsules.
- */
-export function createResourceLimitGate(options) {
-    const { maxStateSize = 1024 * 1024, maxComponents = 100, maxActions = 1000 } = options;
-    const actionCounts = new Map();
-    return {
-        name: 'resource-limit',
-        check: (type, context) => {
-            // Check state size
-            if (type === 'state-change' && context.state) {
-                const stateSize = JSON.stringify(context.state).length;
-                if (stateSize > maxStateSize) {
-                    return {
-                        allowed: false,
-                        reason: `State size (${stateSize} bytes) exceeds limit (${maxStateSize} bytes)`,
-                    };
-                }
-            }
-            // Check action count
-            if (type === 'action') {
-                const count = (actionCounts.get(context.capsuleId) || 0) + 1;
-                if (count > maxActions) {
-                    return {
-                        allowed: false,
-                        reason: `Maximum action count (${maxActions}) exceeded`,
-                    };
-                }
-                actionCounts.set(context.capsuleId, count);
-            }
-            return { allowed: true };
-        },
-    };
-}
-/**
- * Audit Logging Policy Gate
- *
- * Logs all policy decisions for audit purposes.
- */
-export function createAuditLogGate(options) {
-    const { logFn, logAllowed = false } = options;
-    return {
-        name: 'audit-log',
-        check: (type, context) => {
-            const shouldLog = logAllowed || type === 'action';
-            if (shouldLog) {
-                logFn({
-                    timestamp: Date.now(),
-                    capsuleId: context.capsuleId,
-                    actionId: context.actionId,
-                    type,
-                    agentId: context.agentId,
-                });
-            }
-            return { allowed: true };
-        },
-    };
-}
-/**
- * Compose multiple policy gates
- */
-export function composePolicyGates(...gates) {
-    return {
-        name: `composed(${gates.map((g) => g.name).join(', ')})`,
-        check: async (type, context) => {
-            let currentContext = context;
-            for (const gate of gates) {
-                const result = await gate.check(type, currentContext);
-                if (!result.allowed) {
-                    return result;
-                }
-                if (result.context) {
-                    currentContext = result.context;
-                }
-            }
-            return { allowed: true, context: currentContext };
-        },
-    };
-}
-/**
- * Create default security policy gates
- */
-export function createDefaultPolicyGates() {
-    return [
-        createRateLimitGate({ maxActionsPerMinute: 60 }),
-        createPropSanitizationGate({ allowHTML: false }),
-        createResourceLimitGate({
-            maxStateSize: 1024 * 1024, // 1MB
-            maxComponents: 100,
-            maxActions: 1000,
-        }),
-    ];
-}
-// Helper functions
-function getPathValue(obj, path) {
-    return path.split('.').reduce((acc, key) => {
-        if (acc && typeof acc === 'object') {
-            return acc[key];
-        }
-        return undefined;
-    }, obj);
-}
-function getValueType(value) {
-    if (value === null)
-        return 'null';
-    if (Array.isArray(value))
-        return 'array';
-    return typeof value;
-}
-//# sourceMappingURL=policy-gates.js.map

package/dist/schema/ui-ir.d.ts.bak

@@ -1,26 +0,0 @@
-/**
- * UI Intermediate Representation Schema
- *
- * Core schema definitions for declarative UI generation.
- */
-import type { UIRoot, UIComponent, UIState, UIAction, StateVariable, StateBinding, EventHandler, Expression } from '../types';
-export type { UIRoot, UIComponent, UIState, UIAction, StateVariable, StateBinding, EventHandler, Expression, };
-/**
- * Schema version
- */
-export declare const UI_IR_VERSION = "1.0.0";
-/**
- * Validate UIRoot structure
- */
-export declare function validateUIRoot(root: unknown): root is UIRoot;
-/**
- * Create empty UI root
- */
-export declare function createEmptyRoot(): UIRoot;
-/**
- * Create UI root from template
- */
-export declare function createRootFromTemplate(template: Partial<UIRoot> & {
-    components: UIComponent[];
-}): UIRoot;
-//# sourceMappingURL=ui-ir.d.ts.map

package/dist/schema/ui-ir.js.bak

@@ -1,51 +0,0 @@
-/**
- * UI Intermediate Representation Schema
- *
- * Core schema definitions for declarative UI generation.
- */
-/**
- * Schema version
- */
-export const UI_IR_VERSION = '1.0.0';
-/**
- * Validate UIRoot structure
- */
-export function validateUIRoot(root) {
-    if (!root || typeof root !== 'object')
-        return false;
-    const r = root;
-    if (typeof r.version !== 'string')
-        return false;
-    if (!Array.isArray(r.components))
-        return false;
-    if (!r.state || typeof r.state !== 'object')
-        return false;
-    if (!Array.isArray(r.actions))
-        return false;
-    return true;
-}
-/**
- * Create empty UI root
- */
-export function createEmptyRoot() {
-    return {
-        version: UI_IR_VERSION,
-        components: [],
-        state: {
-            variables: [],
-        },
-        actions: [],
-    };
-}
-/**
- * Create UI root from template
- */
-export function createRootFromTemplate(template) {
-    return {
-        version: UI_IR_VERSION,
-        state: { variables: [] },
-        actions: [],
-        ...template,
-    };
-}
-//# sourceMappingURL=ui-ir.js.map

package/dist/sdk/api.d.ts.bak

@@ -1,101 +0,0 @@
-/**
- * A2R-IX API SDK
- *
- * Client for interacting with the A2R-IX API.
- */
-import type { UIRoot } from '../types';
-import type { JSONPatch } from '../state/patch';
-export interface IXCapsuleClientConfig {
-    /** API base URL */
-    baseUrl: string;
-    /** Optional auth token */
-    token?: string;
-    /** Event callbacks */
-    onEvent?: (event: IXCapsuleEvent) => void;
-    /** Error handler */
-    onError?: (error: Error) => void;
-}
-export interface IXCapsuleEvent {
-    event_type: 'lifecycle' | 'action' | 'state-change' | 'error';
-    capsule_id: string;
-    lifecycle?: 'mount' | 'unmount' | 'update';
-    action?: string;
-    action_params?: Record<string, unknown>;
-    state_update?: Record<string, unknown>;
-    error?: string;
-}
-export interface CreateCapsuleRequest {
-    ui: UIRoot;
-    initial_state?: Record<string, unknown>;
-    ttl_seconds?: number;
-}
-export interface CreateCapsuleResponse {
-    capsule_id: string;
-    status: string;
-}
-export interface CapsuleState {
-    capsule_id: string;
-    ui: UIRoot;
-    state: Record<string, unknown>;
-    created_at: string;
-    updated_at: string;
-}
-export interface JsonRenderRequest {
-    schema: Record<string, unknown>;
-    initial_state?: Record<string, unknown>;
-    ttl_seconds?: number;
-}
-export interface ActionRequest {
-    action_id: string;
-    params?: Record<string, unknown>;
-}
-/**
- * A2R-IX Capsule Client
- */
-export declare class IXCapsuleClient {
-    private config;
-    private eventSource;
-    private activeCapsules;
-    constructor(config: IXCapsuleClientConfig);
-    /**
-     * Create a new IX capsule
-     */
-    createCapsule(request: CreateCapsuleRequest): Promise<CreateCapsuleResponse>;
-    /**
-     * Create capsule from json-render format
-     */
-    createFromJsonRender(request: JsonRenderRequest): Promise<CreateCapsuleResponse>;
-    /**
-     * Get capsule state
-     */
-    getCapsule(capsuleId: string): Promise<CapsuleState>;
-    /**
-     * Apply JSON Patch to capsule state
-     */
-    applyPatch(capsuleId: string, patch: JSONPatch): Promise<void>;
-    /**
-     * Dispatch action to capsule
-     */
-    dispatchAction(capsuleId: string, action: ActionRequest): Promise<void>;
-    /**
-     * Delete capsule
-     */
-    deleteCapsule(capsuleId: string): Promise<void>;
-    /**
-     * Connect to event stream
-     */
-    private connectEventStream;
-    /**
-     * Disconnect event stream
-     */
-    private disconnectEventStream;
-    /**
-     * Cleanup all connections
-     */
-    dispose(): void;
-}
-/**
- * Create IX capsule client
- */
-export declare function createIXClient(config: IXCapsuleClientConfig): IXCapsuleClient;
-//# sourceMappingURL=api.d.ts.map

package/dist/sdk/api.js.bak

@@ -1,177 +0,0 @@
-/**
- * A2R-IX API SDK
- *
- * Client for interacting with the A2R-IX API.
- */
-/**
- * A2R-IX Capsule Client
- */
-export class IXCapsuleClient {
-    config;
-    eventSource = null;
-    activeCapsules = new Set();
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * Create a new IX capsule
-     */
-    async createCapsule(request) {
-        const response = await fetch(`${this.config.baseUrl}/ix/capsules`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...(this.config.token && { 'Authorization': `Bearer ${this.config.token}` }),
-            },
-            body: JSON.stringify(request),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to create capsule: ${response.statusText}`);
-        }
-        const result = await response.json();
-        this.activeCapsules.add(result.capsule_id);
-        // Start event stream
-        this.connectEventStream(result.capsule_id);
-        return result;
-    }
-    /**
-     * Create capsule from json-render format
-     */
-    async createFromJsonRender(request) {
-        const response = await fetch(`${this.config.baseUrl}/ix/capsules/json-render`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...(this.config.token && { 'Authorization': `Bearer ${this.config.token}` }),
-            },
-            body: JSON.stringify(request),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to create capsule: ${response.statusText}`);
-        }
-        const result = await response.json();
-        this.activeCapsules.add(result.capsule_id);
-        // Start event stream
-        this.connectEventStream(result.capsule_id);
-        return result;
-    }
-    /**
-     * Get capsule state
-     */
-    async getCapsule(capsuleId) {
-        const response = await fetch(`${this.config.baseUrl}/ix/capsules/${capsuleId}`, {
-            headers: {
-                ...(this.config.token && { 'Authorization': `Bearer ${this.config.token}` }),
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to get capsule: ${response.statusText}`);
-        }
-        return response.json();
-    }
-    /**
-     * Apply JSON Patch to capsule state
-     */
-    async applyPatch(capsuleId, patch) {
-        const response = await fetch(`${this.config.baseUrl}/ix/capsules/${capsuleId}/patch`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...(this.config.token && { 'Authorization': `Bearer ${this.config.token}` }),
-            },
-            body: JSON.stringify({ operations: patch }),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to apply patch: ${response.statusText}`);
-        }
-    }
-    /**
-     * Dispatch action to capsule
-     */
-    async dispatchAction(capsuleId, action) {
-        const response = await fetch(`${this.config.baseUrl}/ix/capsules/${capsuleId}/action`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...(this.config.token && { 'Authorization': `Bearer ${this.config.token}` }),
-            },
-            body: JSON.stringify(action),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to dispatch action: ${response.statusText}`);
-        }
-    }
-    /**
-     * Delete capsule
-     */
-    async deleteCapsule(capsuleId) {
-        const response = await fetch(`${this.config.baseUrl}/ix/capsules/${capsuleId}`, {
-            method: 'DELETE',
-            headers: {
-                ...(this.config.token && { 'Authorization': `Bearer ${this.config.token}` }),
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to delete capsule: ${response.statusText}`);
-        }
-        this.activeCapsules.delete(capsuleId);
-        this.disconnectEventStream(capsuleId);
-    }
-    /**
-     * Connect to event stream
-     */
-    connectEventStream(capsuleId) {
-        if (typeof EventSource === 'undefined') {
-            console.warn('EventSource not available');
-            return;
-        }
-        const url = new URL(`${this.config.baseUrl}/ix/capsules/${capsuleId}/stream`);
-        if (this.config.token) {
-            url.searchParams.set('token', this.config.token);
-        }
-        const es = new EventSource(url.toString());
-        this.eventSource = es;
-        es.onmessage = (event) => {
-            try {
-                const data = JSON.parse(event.data);
-                this.config.onEvent?.(data);
-                // Handle unmount - cleanup
-                if (data.event_type === 'lifecycle' && data.lifecycle === 'unmount') {
-                    this.activeCapsules.delete(capsuleId);
-                    this.disconnectEventStream(capsuleId);
-                }
-            }
-            catch (error) {
-                this.config.onError?.(error);
-            }
-        };
-        es.onerror = (error) => {
-            this.config.onError?.(new Error('EventSource error'));
-        };
-    }
-    /**
-     * Disconnect event stream
-     */
-    disconnectEventStream(capsuleId) {
-        if (this.eventSource) {
-            this.eventSource.close();
-            this.eventSource = null;
-        }
-    }
-    /**
-     * Cleanup all connections
-     */
-    dispose() {
-        this.activeCapsules.forEach((id) => {
-            this.disconnectEventStream(id);
-        });
-        this.activeCapsules.clear();
-    }
-}
-/**
- * Create IX capsule client
- */
-export function createIXClient(config) {
-    return new IXCapsuleClient(config);
-}
-//# sourceMappingURL=api.js.map

package/dist/sdk/index.d.ts.bak

@@ -1,9 +0,0 @@
-/**
- * A2R-IX SDK
- *
- * Client SDK for A2R-IX integration.
- */
-export { IXCapsuleClient, createIXClient, type IXCapsuleClientConfig, type IXCapsuleEvent, type CreateCapsuleRequest, type CreateCapsuleResponse, type CapsuleState, type JsonRenderRequest, type ActionRequest, } from './api';
-export { IXProvider, IXRenderer, useIX, useIXState, useIXAction, } from './react';
-export type { UIRoot, JSONPatch } from '../types';
-//# sourceMappingURL=index.d.ts.map

package/dist/sdk/index.js.bak

@@ -1,10 +0,0 @@
-/**
- * A2R-IX SDK
- *
- * Client SDK for A2R-IX integration.
- */
-// API Client
-export { IXCapsuleClient, createIXClient, } from './api';
-// React Integration
-export { IXProvider, IXRenderer, useIX, useIXState, useIXAction, } from './react';
-//# sourceMappingURL=index.js.map