Plugin Architecture

How Plugins Power Stavily

Everything in Stavily is a plugin. Our architecture ensures infinite flexibility while maintaining security, performance, and ease of use.

Core Design Principles

Our plugin system is built on six fundamental principles that ensure flexibility, security, and ease of use:

Plugin-First Design: Every feature in Stavily is a plugin - no exceptions
TRIGGER → ACTION → OUTPUT: Every workflow follows this predictable pattern
Multi-Language Support: Python, Go, JavaScript, and Rust with more coming
Git-Based Distribution: Zero vendor lock-in through open Git repositories
Community Ecosystem: Revenue-sharing marketplace for sustainable growth
Security by Design: Sandboxed execution with comprehensive controls

How It All Fits Together

Plugins live in Git repositories and are managed centrally by the Orchestrator, which handles validation, security, and deployment to agents.

graph TD
    A[Git Repositories] --> B[Orchestrator]
    B --> C[Sensor Agents]
    B --> D[Action Agents]

    B --> E[Plugin Validation]
    B --> F[Security Scanning]
    B --> G[Version Management]

    C --> H[Trigger Plugins]
    D --> I[Action Plugins]
    D --> J[Output Plugins]

Plugin Types

Every automation follows our TRIGGER → ACTION → OUTPUT pattern. Each type serves a specific role in the workflow:

Triggers: Event Detection

What they do: Detect events and start workflows Where they run: Usually in the cloud orchestrator for scalability Examples:

Monitor email inboxes for new messages
Watch APIs for status changes
Schedule time-based tasks
Track system health metrics

Actions: Task Execution

What they do: Perform the actual automation work Where they run: On action agents in your infrastructure Examples:

Run system commands
Send notifications
Process data
Update configurations

Outputs: Result Handling

What they do: Process and deliver action results Where they run: On action agents alongside actions Examples:

Send alerts to Slack/Teams
Log results to databases
Generate reports
Update dashboards

Smart Agent Targeting

Plugins can target specific agents or groups based on your infrastructure needs:

Single Agent: Run on a specific server or device
Agent Pools: Load-balanced execution across similar agents
Groups: Target by environment (production, staging), region, or role
Affected Agents: Automatically run on agents that detected the triggering event

This flexibility ensures your automations run exactly where and when needed.

Plugin Management Made Simple

The Orchestrator handles everything automatically - you just point it to Git repositories:

Register plugin repositories (GitHub, GitLab, or private repos)
Validate security and compatibility automatically
Deploy to agents with zero manual configuration
Update plugins seamlessly when new versions are available

Zero vendor lock-in: All plugins are just Git repositories you control.

Plugin Manifest Structure

plugin:
  name: "system-command-action"
  version: "1.2.0"
  type: "action"
  description: "Execute system commands with configurable timeout and error handling"

  author:
    name: "Stavily Team"
    email: "[email protected]"

  runtime:
    language: "python"
    min_version: "3.8"
    dependencies:
      - "psutil>=5.8.0"
      - "subprocess32>=3.5.4"

  compatibility:
    programming_language:
      name: "python"
      min_version: ">=3.8.0"
      max_version: "<4.0.0"
    library_dependencies:
      psutil: ">=5.8.0,<6.0.0"
      subprocess32: ">=3.5.4,<4.0.0"
    os_requirements:
      supported_os: ["linux", "darwin", "windows"]
      supported_architectures: ["amd64", "arm64"]
      min_kernel_version: "4.15.0"  # For Linux
      required_libraries: ["libc6"]
    execution_limits:
      max_memory_mb: 128
      max_cpu_cores: 0.5
      max_execution_time_seconds: 600
      max_file_descriptors: 50
      max_network_connections: 5
      sandbox_mode: true
      allow_network_access: false
      allow_filesystem_access: "restricted"
      allowed_system_calls: ["read", "write", "open", "close", "execve", "fork", "wait"]

  permissions:
    system:
      - "process.execute"
      - "filesystem.read"
    network:
      - "dns.resolve"

  configuration:
    schema: "config-schema.json"
    examples: "examples/"

  testing:
    test_suite: "tests/"
    coverage_threshold: 80

Security First

Every plugin runs in a secure sandbox with strict controls:

Signature Verification: All plugins are cryptographically signed
Permission Controls: Explicit permissions for network, filesystem, and system access
Resource Limits: CPU, memory, and network usage caps
Process Isolation: Complete separation from host system
Audit Logging: Full activity tracking and monitoring

Enterprise-grade security without compromising flexibility.

Marketplace & Community

Our plugin marketplace offers different tiers for every need:

Free: Community plugins and open source contributions
Premium: Professional plugins with support ($5-50/month)
Enterprise: Mission-critical plugins with SLA support ($100-1000/month)

Fair revenue sharing: Developers keep 60-70% of subscription revenue.

Why This Architecture Matters

Plugin-first design means Stavily can adapt to any automation need without core platform changes. Whether you need to monitor IoT devices, integrate with legacy systems, or automate complex business processes - plugins make it possible.

Security and performance are built-in, not afterthoughts. Every plugin runs in isolation with strict resource controls, ensuring your infrastructure stays safe and stable.

Community and marketplace create a flywheel effect: more users → more plugins → more value for everyone.