@bluefly/openstandardagents 0.5.1 → 0.5.3

package/dist/deploy/base-driver.d.ts

@@ -1,39 +0,0 @@
-/**
- * OSSA Base Deployment Driver
- * Abstract base class for deployment drivers
- */
-import type { IDeploymentDriver, DeploymentConfig, DeploymentResult, InstanceInfo, RollbackOptions, HealthCheckResult } from './types.js';
-import type { OssaAgent } from '../types/index.js';
-/**
- * Base deployment driver with common functionality
- */
-export declare abstract class BaseDeploymentDriver implements IDeploymentDriver {
-    protected instances: Map<string, InstanceInfo>;
-    /**
-     * Generate a unique instance ID
-     */
-    protected generateInstanceId(manifest: OssaAgent, config: DeploymentConfig): string;
-    /**
-     * Validate manifest before deployment
-     */
-    protected validateManifest(manifest: OssaAgent): void;
-    /**
-     * Create instance info from deployment
-     */
-    protected createInstanceInfo(instanceId: string, manifest: OssaAgent, config: DeploymentConfig, endpoint?: string): InstanceInfo;
-    /**
-     * Store instance information
-     */
-    protected storeInstance(instance: InstanceInfo): void;
-    /**
-     * Get stored instance
-     */
-    protected getInstance(instanceId: string): InstanceInfo | undefined;
-    abstract deploy(manifest: OssaAgent, config: DeploymentConfig): Promise<DeploymentResult>;
-    abstract getStatus(instanceId: string): Promise<InstanceInfo>;
-    abstract listInstances(): Promise<InstanceInfo[]>;
-    abstract stop(instanceId: string): Promise<void>;
-    abstract rollback(instanceId: string, options: RollbackOptions): Promise<DeploymentResult>;
-    abstract healthCheck(instanceId: string): Promise<HealthCheckResult>;
-}
-//# sourceMappingURL=base-driver.d.ts.map

package/dist/deploy/base-driver.js

@@ -1,63 +0,0 @@
-/**
- * OSSA Base Deployment Driver
- * Abstract base class for deployment drivers
- */
-/**
- * Base deployment driver with common functionality
- */
-export class BaseDeploymentDriver {
-    instances = new Map();
-    /**
-     * Generate a unique instance ID
-     */
-    generateInstanceId(manifest, config) {
-        const name = manifest.metadata?.name || 'agent';
-        const version = config.version || manifest.metadata?.version || '1.0.0';
-        const timestamp = Date.now();
-        return `${name}-${version}-${config.environment}-${timestamp}`;
-    }
-    /**
-     * Validate manifest before deployment
-     */
-    validateManifest(manifest) {
-        if (!manifest.metadata) {
-            throw new Error('Invalid manifest: missing metadata');
-        }
-        if (!manifest.spec) {
-            throw new Error('Invalid manifest: missing spec');
-        }
-        if (!manifest.metadata.name) {
-            throw new Error('Invalid manifest: missing metadata.name');
-        }
-    }
-    /**
-     * Create instance info from deployment
-     */
-    createInstanceInfo(instanceId, manifest, config, endpoint) {
-        return {
-            id: instanceId,
-            name: manifest.metadata?.name || 'agent',
-            status: 'running',
-            deployedAt: new Date().toISOString(),
-            version: config.version || manifest.metadata?.version || '1.0.0',
-            endpoint,
-            metadata: {
-                environment: config.environment,
-                target: config.target,
-            },
-        };
-    }
-    /**
-     * Store instance information
-     */
-    storeInstance(instance) {
-        this.instances.set(instance.id, instance);
-    }
-    /**
-     * Get stored instance
-     */
-    getInstance(instanceId) {
-        return this.instances.get(instanceId);
-    }
-}
-//# sourceMappingURL=base-driver.js.map

package/dist/deploy/cloud/aws-driver.d.ts

@@ -1,75 +0,0 @@
-/**
- * AWS Deployment Driver
- * Deploys OSSA agents to AWS (ECS, Fargate, Lambda)
- *
- * Features:
- * - ECS Fargate deployment
- * - Lambda function deployment
- * - Auto-scaling configuration
- * - CloudWatch monitoring integration
- * - VPC and security group configuration
- */
-import { BaseDeploymentDriver } from '../base-driver.js';
-import type { DeploymentConfig, DeploymentResult, InstanceInfo, RollbackOptions, HealthCheckResult } from '../types.js';
-import type { OssaAgent } from '../../types/index.js';
-export interface AWSDeploymentConfig extends DeploymentConfig {
-    cluster?: string;
-    taskDefinition?: string;
-    serviceName?: string;
-    cpu?: string;
-    memory?: string;
-    subnets?: string[];
-    securityGroups?: string[];
-    assignPublicIp?: boolean;
-    functionName?: string;
-    runtime?: string;
-    handler?: string;
-    timeout?: number;
-    memorySize?: number;
-    region?: string;
-    tags?: Record<string, string>;
-}
-/**
- * AWS deployment driver - deploys agents to ECS Fargate or Lambda
- */
-export declare class AWSDeploymentDriver extends BaseDeploymentDriver {
-    private awsInstances;
-    /**
-     * Check if AWS CLI is available
-     */
-    private checkAWSAvailable;
-    /**
-     * Deploy to AWS
-     */
-    deploy(manifest: OssaAgent, config: AWSDeploymentConfig): Promise<DeploymentResult>;
-    /**
-     * Determine deployment type based on runtime configuration
-     */
-    private determineDeploymentType;
-    /**
-     * Deploy to AWS Lambda
-     */
-    private deployToLambda;
-    /**
-     * Deploy to AWS ECS Fargate
-     */
-    private deployToECS;
-    /**
-     * Generate ECS task definition
-     */
-    private generateECSTaskDefinition;
-    /**
-     * Check if Lambda function exists
-     */
-    private checkLambdaExists;
-    /**
-     * Check if ECS service exists
-     */
-    private checkECSServiceExists;
-    getStatus(instanceId: string): Promise<InstanceInfo>;
-    listInstances(): Promise<InstanceInfo[]>;
-    stop(instanceId: string): Promise<void>;
-    rollback(instanceId: string, options: RollbackOptions): Promise<DeploymentResult>;
-    healthCheck(instanceId: string): Promise<HealthCheckResult>;
-}
-//# sourceMappingURL=aws-driver.d.ts.map

package/dist/deploy/cloud/aws-driver.js

@@ -1,349 +0,0 @@
-/**
- * AWS Deployment Driver
- * Deploys OSSA agents to AWS (ECS, Fargate, Lambda)
- *
- * Features:
- * - ECS Fargate deployment
- * - Lambda function deployment
- * - Auto-scaling configuration
- * - CloudWatch monitoring integration
- * - VPC and security group configuration
- */
-import { BaseDeploymentDriver } from '../base-driver.js';
-/**
- * AWS deployment driver - deploys agents to ECS Fargate or Lambda
- */
-export class AWSDeploymentDriver extends BaseDeploymentDriver {
-    awsInstances = new Map();
-    /**
-     * Check if AWS CLI is available
-     */
-    async checkAWSAvailable() {
-        try {
-            const { exec } = await import('child_process');
-            const { promisify } = await import('util');
-            const execAsync = promisify(exec);
-            await execAsync('aws --version');
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Deploy to AWS
-     */
-    async deploy(manifest, config) {
-        this.validateManifest(manifest);
-        const awsAvailable = await this.checkAWSAvailable();
-        if (!awsAvailable) {
-            return {
-                success: false,
-                message: 'AWS CLI is not available. Please install AWS CLI and configure credentials.',
-            };
-        }
-        const instanceId = this.generateInstanceId(manifest, config);
-        const region = config.region || process.env.AWS_REGION || 'us-east-1';
-        // Determine deployment type (ECS or Lambda)
-        const runtime = manifest.agent?.runtime;
-        const deploymentType = this.determineDeploymentType(runtime);
-        if (config.dryRun) {
-            return {
-                success: true,
-                message: '[DRY RUN] Would deploy to AWS',
-                metadata: {
-                    name: manifest.metadata?.name,
-                    version: config.version || manifest.metadata?.version,
-                    environment: config.environment,
-                    region,
-                    deploymentType,
-                },
-            };
-        }
-        try {
-            let result;
-            if (deploymentType === 'lambda') {
-                result = await this.deployToLambda(manifest, config, instanceId, region);
-            }
-            else {
-                result = await this.deployToECS(manifest, config, instanceId, region);
-            }
-            if (result.success) {
-                const instance = this.createInstanceInfo(instanceId, manifest, config, result.endpoint);
-                instance.metadata = {
-                    ...instance.metadata,
-                    region,
-                    deploymentType,
-                    ...result.metadata,
-                };
-                this.awsInstances.set(instanceId, instance);
-                this.storeInstance(instance);
-            }
-            return result;
-        }
-        catch (error) {
-            return {
-                success: false,
-                message: `AWS deployment failed: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    /**
-     * Determine deployment type based on runtime configuration
-     */
-    determineDeploymentType(runtime) {
-        // If runtime specifies Lambda handler, use Lambda
-        if (runtime?.handler || runtime?.type === 'lambda') {
-            return 'lambda';
-        }
-        // Default to ECS Fargate for containerized workloads
-        return 'ecs';
-    }
-    /**
-     * Deploy to AWS Lambda
-     */
-    async deployToLambda(manifest, config, instanceId, region) {
-        const { exec } = await import('child_process');
-        const { promisify } = await import('util');
-        const execAsync = promisify(exec);
-        const functionName = config.functionName || `ossa-${manifest.metadata?.name || 'agent'}`;
-        const runtime = config.runtime || 'nodejs20.x';
-        const handler = config.handler || 'index.handler';
-        const timeout = config.timeout || 60;
-        const memorySize = config.memorySize || 512;
-        try {
-            // Check if function exists
-            const functionExists = await this.checkLambdaExists(functionName, region);
-            if (functionExists) {
-                // Update existing function
-                await execAsync(`aws lambda update-function-code --function-name ${functionName} --region ${region} --zip-file fileb://function.zip`);
-            }
-            else {
-                // Create new function
-                const createCmd = [
-                    `aws lambda create-function`,
-                    `--function-name ${functionName}`,
-                    `--runtime ${runtime}`,
-                    `--handler ${handler}`,
-                    `--timeout ${timeout}`,
-                    `--memory-size ${memorySize}`,
-                    `--region ${region}`,
-                    `--role ${config.tags?.role || 'arn:aws:iam::ACCOUNT:role/lambda-role'}`,
-                    `--zip-file fileb://function.zip`,
-                ].join(' ');
-                await execAsync(createCmd);
-            }
-            // Get function URL
-            const { stdout } = await execAsync(`aws lambda get-function --function-name ${functionName} --region ${region} --query 'Configuration.FunctionArn' --output text`);
-            const functionArn = stdout.trim();
-            return {
-                success: true,
-                message: `Deployed to AWS Lambda: ${functionName}`,
-                instanceId,
-                endpoint: `https://lambda.${region}.amazonaws.com/functions/${functionName}`,
-                metadata: {
-                    functionName,
-                    functionArn,
-                    runtime,
-                    region,
-                },
-            };
-        }
-        catch (error) {
-            throw new Error(`Lambda deployment failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Deploy to AWS ECS Fargate
-     */
-    async deployToECS(manifest, config, instanceId, region) {
-        const { exec } = await import('child_process');
-        const { promisify } = await import('util');
-        const execAsync = promisify(exec);
-        const cluster = config.cluster || 'default';
-        const serviceName = config.serviceName || `ossa-${manifest.metadata?.name || 'agent'}`;
-        const cpu = config.cpu || '256';
-        const memory = config.memory || '512';
-        try {
-            // Register task definition
-            const taskDef = this.generateECSTaskDefinition(manifest, config, instanceId);
-            const taskDefJson = JSON.stringify(taskDef);
-            // Write task definition to temp file and register
-            const fs = await import('fs');
-            const tmpFile = `/tmp/task-def-${instanceId}.json`;
-            fs.writeFileSync(tmpFile, taskDefJson);
-            const { stdout: registerOutput } = await execAsync(`aws ecs register-task-definition --region ${region} --cli-input-json file://${tmpFile} --query 'taskDefinition.taskDefinitionArn' --output text`);
-            const taskDefArn = registerOutput.trim();
-            // Create or update service
-            const serviceExists = await this.checkECSServiceExists(serviceName, cluster, region);
-            if (serviceExists) {
-                // Update service
-                await execAsync(`aws ecs update-service --region ${region} --cluster ${cluster} --service ${serviceName} --task-definition ${taskDefArn} --desired-count ${config.replicas || 1}`);
-            }
-            else {
-                // Create service
-                const createServiceCmd = [
-                    `aws ecs create-service`,
-                    `--region ${region}`,
-                    `--cluster ${cluster}`,
-                    `--service-name ${serviceName}`,
-                    `--task-definition ${taskDefArn}`,
-                    `--desired-count ${config.replicas || 1}`,
-                    `--launch-type FARGATE`,
-                    config.subnets
-                        ? `--network-configuration "awsvpcConfiguration={subnets=[${config.subnets.join(',')}],securityGroups=[${config.securityGroups?.join(',') || ''}],assignPublicIp=${config.assignPublicIp ? 'ENABLED' : 'DISABLED'}}"`
-                        : '',
-                ]
-                    .filter(Boolean)
-                    .join(' ');
-                await execAsync(createServiceCmd);
-            }
-            // Clean up temp file
-            fs.unlinkSync(tmpFile);
-            return {
-                success: true,
-                message: `Deployed to AWS ECS: ${serviceName}`,
-                instanceId,
-                endpoint: `https://${serviceName}.${region}.amazonaws.com`,
-                metadata: {
-                    cluster,
-                    serviceName,
-                    taskDefinition: taskDefArn,
-                    region,
-                },
-            };
-        }
-        catch (error) {
-            throw new Error(`ECS deployment failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Generate ECS task definition
-     */
-    generateECSTaskDefinition(manifest, config, instanceId) {
-        const image = config.dockerImage || manifest.agent?.runtime?.image || 'node:20-alpine';
-        return {
-            family: `ossa-${manifest.metadata?.name || 'agent'}`,
-            networkMode: 'awsvpc',
-            requiresCompatibilities: ['FARGATE'],
-            cpu: config.cpu || '256',
-            memory: config.memory || '512',
-            containerDefinitions: [
-                {
-                    name: 'agent',
-                    image,
-                    portMappings: [
-                        {
-                            containerPort: 3000,
-                            protocol: 'tcp',
-                        },
-                    ],
-                    environment: [
-                        {
-                            name: 'OSSA_AGENT_NAME',
-                            value: manifest.metadata?.name || 'agent',
-                        },
-                        {
-                            name: 'OSSA_ENVIRONMENT',
-                            value: config.environment,
-                        },
-                        {
-                            name: 'OSSA_VERSION',
-                            value: config.version || manifest.metadata?.version || '1.0.0',
-                        },
-                    ],
-                    logConfiguration: {
-                        logDriver: 'awslogs',
-                        options: {
-                            'awslogs-group': `/ecs/ossa-${manifest.metadata?.name || 'agent'}`,
-                            'awslogs-region': config.region || 'us-east-1',
-                            'awslogs-stream-prefix': 'ecs',
-                        },
-                    },
-                },
-            ],
-        };
-    }
-    /**
-     * Check if Lambda function exists
-     */
-    async checkLambdaExists(functionName, region) {
-        try {
-            const { exec } = await import('child_process');
-            const { promisify } = await import('util');
-            const execAsync = promisify(exec);
-            await execAsync(`aws lambda get-function --function-name ${functionName} --region ${region}`);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Check if ECS service exists
-     */
-    async checkECSServiceExists(serviceName, cluster, region) {
-        try {
-            const { exec } = await import('child_process');
-            const { promisify } = await import('util');
-            const execAsync = promisify(exec);
-            const { stdout } = await execAsync(`aws ecs describe-services --region ${region} --cluster ${cluster} --services ${serviceName} --query 'services[0].status' --output text`);
-            return stdout.trim() !== 'None' && stdout.trim() !== '';
-        }
-        catch {
-            return false;
-        }
-    }
-    async getStatus(instanceId) {
-        const instance = this.awsInstances.get(instanceId);
-        if (!instance) {
-            throw new Error(`Instance ${instanceId} not found`);
-        }
-        return instance;
-    }
-    async listInstances() {
-        return Array.from(this.awsInstances.values());
-    }
-    async stop(instanceId) {
-        const instance = this.awsInstances.get(instanceId);
-        if (!instance) {
-            throw new Error(`Instance ${instanceId} not found`);
-        }
-        // Implementation depends on deployment type (ECS or Lambda)
-        // For now, mark as stopped
-        this.awsInstances.delete(instanceId);
-    }
-    async rollback(instanceId, options) {
-        const instance = this.awsInstances.get(instanceId);
-        if (!instance) {
-            throw new Error(`Instance ${instanceId} not found`);
-        }
-        const previousVersion = instance.version;
-        this.awsInstances.set(instanceId, {
-            ...instance,
-            version: options.targetVersion || previousVersion,
-        });
-        return {
-            success: true,
-            message: `Rollback completed for ${instanceId}`,
-            instanceId,
-        };
-    }
-    async healthCheck(instanceId) {
-        const instance = this.awsInstances.get(instanceId);
-        if (!instance) {
-            return {
-                healthy: false,
-                status: 'unknown',
-                message: 'Instance not found',
-            };
-        }
-        // Basic health check - would integrate with CloudWatch in production
-        return {
-            healthy: true,
-            status: 'healthy',
-            message: 'Service is running',
-        };
-    }
-}
-//# sourceMappingURL=aws-driver.js.map

package/dist/deploy/cloud/azure-driver.d.ts

@@ -1,54 +0,0 @@
-/**
- * Azure Deployment Driver
- * Deploys OSSA agents to Microsoft Azure (Container Instances, AKS)
- *
- * Features:
- * - Azure Container Instances (ACI) deployment
- * - Azure Kubernetes Service (AKS) deployment
- * - Auto-scaling configuration
- * - Azure Monitor integration
- */
-import { BaseDeploymentDriver } from '../base-driver.js';
-import type { DeploymentConfig, DeploymentResult, InstanceInfo, RollbackOptions, HealthCheckResult } from '../types.js';
-import type { OssaAgent } from '../../types/index.js';
-export interface AzureDeploymentConfig extends DeploymentConfig {
-    containerName?: string;
-    resourceGroup?: string;
-    location?: string;
-    cpu?: number;
-    memory?: number;
-    ports?: number[];
-    dnsNameLabel?: string;
-    aksCluster?: string;
-    aksResourceGroup?: string;
-    subscriptionId?: string;
-    tags?: Record<string, string>;
-}
-/**
- * Azure deployment driver - deploys agents to Container Instances or AKS
- */
-export declare class AzureDeploymentDriver extends BaseDeploymentDriver {
-    private azureInstances;
-    /**
-     * Check if Azure CLI is available
-     */
-    private checkAzureAvailable;
-    /**
-     * Deploy to Azure
-     */
-    deploy(manifest: OssaAgent, config: AzureDeploymentConfig): Promise<DeploymentResult>;
-    /**
-     * Deploy to Azure Container Instances
-     */
-    private deployToACI;
-    /**
-     * Deploy to Azure Kubernetes Service
-     */
-    private deployToAKS;
-    getStatus(instanceId: string): Promise<InstanceInfo>;
-    listInstances(): Promise<InstanceInfo[]>;
-    stop(instanceId: string): Promise<void>;
-    rollback(instanceId: string, options: RollbackOptions): Promise<DeploymentResult>;
-    healthCheck(instanceId: string): Promise<HealthCheckResult>;
-}
-//# sourceMappingURL=azure-driver.d.ts.map