archsight 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '02159c7a5daad27f25979069c4b99ffaf571a21d39aff2cab0f5596a3214f897'
-  data.tar.gz: ab77c07451e71853aaca877b2642df46ffc32c81b5dfbcc0d7b86893a26ef955
+  metadata.gz: 697c02b1e33af4fde32636af6020b7ab6513245216b694453d03dab186f0dd99
+  data.tar.gz: 58a8cd9b7e530796d04424f885e931863a1bf6ed2c2d0366bf76d28453eb80fb
 SHA512:
-  metadata.gz: d753c04025bea2bb8ce93b55e0cb479eb3c44ad756d1e123b1cda844119fedfcce43d8f4b824d6cefd6c5c98401099eaa00c1416cc2302f2486514917f3df05e
-  data.tar.gz: 3992fc81f881e7de8c751c6af12354463eabfeb8ac30d8019106ec0676d792543cdf4b4658aef1075b5f8a85d1ef037d31cfe0b33df0b2867de7d0f3b1b97157
+  metadata.gz: a80fc22f8b7030c71cb2422b839521e96f31ecced71386ed075c51d9ca2d53d2a057ced240a4085ad032c895ce8526d44a585b6970c67f2217fe15232a2209cd
+  data.tar.gz: 3d0648dca25e6337679d6a236b256b5580d9a5260df927a792680e5e9187e289b0c781aa36d0fb81893fea3889e57b7ec1b7a397d731039d5f5dcbebdff2f587

data/Dockerfile

@@ -1,39 +1,38 @@
-FROM ruby:4.0-alpine3.23
+# Build stage
+FROM ruby:4.0-alpine3.23 AS builder
 
-# Install system dependencies required for building gems
-RUN apk add --no-cache \
-    build-base \
-    git \
-    libffi-dev \
-    yaml-dev \
-    graphviz
+RUN apk add --no-cache build-base git libffi-dev yaml-dev
 
-# Set working directory
 WORKDIR /app
+COPY . .
+
+# Build and install the gem
+RUN gem build archsight.gemspec && \
+    gem install --no-document archsight-*.gem
 
-# Copy gemspec, Gemfile, and .ruby-version for dependency installation
-COPY archsight.gemspec Gemfile Gemfile.lock* .ruby-version ./
-COPY lib/archsight/version.rb lib/archsight/version.rb
+# Runtime stage
+FROM ruby:4.0-alpine3.23
 
-# Install Ruby dependencies
-RUN bundle install --jobs 4
+RUN apk add --no-cache graphviz
 
-# Copy application code
-COPY . .
+# Copy installed gems from builder (including default gems that were updated)
+COPY --from=builder /usr/local/bundle /usr/local/bundle
+COPY --from=builder /usr/local/lib/ruby/gems /usr/local/lib/ruby/gems
+
+# Ensure Ruby finds gems in both /usr/local/bundle and default gems location
+ENV GEM_HOME=/usr/local/bundle
+ENV GEM_PATH=/usr/local/bundle:/usr/local/lib/ruby/gems/4.0.0
+ENV PATH="/usr/local/bundle/bin:${PATH}"
 
-# Create volume mount point for resources
 RUN mkdir -p /resources
 
-# Set resources directory environment variable
 ENV ARCHSIGHT_RESOURCES_DIR=/resources
 ENV APP_ENV=production
 
-# Expose port for web server
 EXPOSE 4567
 
-# Health check
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
     CMD wget --no-verbose --tries=1 --spider http://localhost:4567/ || exit 1
 
-# Default command - use the archsight CLI
-CMD ["bundle", "exec", "exe/archsight", "web", "--port", "4567"]
+ENTRYPOINT ["archsight"]
+CMD ["web", "--port", "4567"]

data/README.md

@@ -41,29 +41,55 @@ Access at: <http://localhost:4567>
 ### Option 2: Docker
 
 ```bash
-docker build -t archsight .
-docker run -p 4567:4567 -v "/path/to/resources:/resources" archsight
+# Run web server (default)
+docker run -p 4567:4567 -v "/path/to/resources:/resources" ghcr.io/ionos-cloud/archsight
+
+# Run in production mode with logging
+docker run -p 4567:4567 -v "/path/to/resources:/resources" ghcr.io/ionos-cloud/archsight web --production
+
+# Run lint
+docker run -v "/path/to/resources:/resources" ghcr.io/ionos-cloud/archsight lint -r /resources
+
+# Run any command
+docker run ghcr.io/ionos-cloud/archsight version
 ```
 
-Access at: <http://localhost:4567>
+Access web interface at: <http://localhost:4567>
 
 **Notes:**
 
-- The volume mount `-v "/path/to/resources:/resources"` mounts your resources directory
-- Resources are accessible at `/resources` inside the container
-- Live YAML updates are reflected without rebuilding
-- Health check verifies the service is running
+- Volume mount `-v "/path/to/resources:/resources"` mounts your resources directory
+- Default command starts the web server on port 4567
+- Pass subcommands directly (lint, version, console, template)
 
 ## CLI Commands
 
 ```bash
-archsight web [--resources PATH] [--port PORT]  # Start web server
-archsight lint [--resources PATH]               # Validate YAML and relations
-archsight template KIND                         # Generate YAML template for a resource type
-archsight console [--resources PATH]            # Interactive Ruby console
-archsight version                               # Show version
+archsight web [OPTIONS]      # Start web server
+archsight lint               # Validate YAML and relations
+archsight import             # Execute pending imports
+archsight analyze            # Execute analysis scripts
+archsight template KIND      # Generate YAML template for a resource type
+archsight console            # Interactive Ruby console
+archsight version            # Show version
 ```
 
+### Web Server Options
+
+```bash
+archsight web [--resources PATH] [--port PORT] [--host HOST]
+              [--production] [--disable-reload] [--enable-logging]
+```
+
+| Option | Description |
+|--------|-------------|
+| `-r, --resources PATH` | Path to resources directory |
+| `-p, --port PORT` | Port to listen on (default: 4567) |
+| `-H, --host HOST` | Host to bind to (default: localhost) |
+| `--production` | Run in production mode (quiet startup) |
+| `--disable-reload` | Disable the reload button in the UI |
+| `--enable-logging` | Enable request logging (default: false in dev, true in prod) |
+
 ## Features
 
 ### MCP Server

data/exe/archsight

@@ -1,7 +1,9 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+# Support running from source (development)
+lib_path = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib_path) if File.directory?(File.join(lib_path, "archsight"))
 
 require "archsight"
 require "archsight/cli"

data/lib/archsight/analysis/executor.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "timeout"
+require_relative "sandbox"
+require_relative "result"
+
+module Archsight
+  module Analysis
+    # Executor runs Analysis scripts in a sandboxed environment with timeout enforcement
+    class Executor
+      # Default timeout in seconds
+      DEFAULT_TIMEOUT = 30
+
+      # Duration parsing patterns
+      DURATION_PATTERNS = {
+        /^(\d+)s$/ => 1,
+        /^(\d+)m$/ => 60,
+        /^(\d+)h$/ => 3600
+      }.freeze
+
+      attr_reader :database
+
+      # @param database [Archsight::Database] Loaded database instance
+      def initialize(database)
+        @database = database
+      end
+
+      # Execute an Analysis resource
+      # @param analysis [Archsight::Resources::Analysis] Analysis to execute
+      # @return [Archsight::Analysis::Result] Execution result
+      def execute(analysis)
+        script = analysis.annotations["analysis/script"]
+        timeout_seconds = parse_timeout(analysis.annotations["analysis/timeout"])
+
+        return Result.new(analysis, success: false, error: "No script defined") if script.nil? || script.empty?
+
+        sandbox = Sandbox.new(@database)
+        sandbox._set_analysis(analysis)
+
+        start_time = Time.now
+        begin
+          Timeout.timeout(timeout_seconds) do
+            # Execute script in sandbox context
+            # Using instance_eval ensures script only has access to sandbox methods
+            sandbox.instance_eval(script, "analysis:#{analysis.name}", 1)
+          end
+
+          duration = Time.now - start_time
+          Result.new(
+            analysis,
+            success: true,
+            sections: sandbox.sections,
+            duration: duration
+          )
+        rescue Timeout::Error
+          Result.new(
+            analysis,
+            success: false,
+            error: "Execution timed out after #{timeout_seconds}s",
+            sections: sandbox.sections
+          )
+        rescue StandardError, SyntaxError => e
+          Result.new(
+            analysis,
+            success: false,
+            error: "#{e.class}: #{e.message}",
+            error_backtrace: e.backtrace&.first(5),
+            sections: sandbox.sections
+          )
+        end
+      end
+
+      # Execute all enabled Analysis resources
+      # @param filter [Regexp, nil] Optional filter for analysis names
+      # @return [Array<Archsight::Analysis::Result>] Array of results
+      def execute_all(filter: nil)
+        analyses = @database.instances_by_kind("Analysis").values
+
+        # Filter by name pattern if provided
+        analyses = analyses.select { |a| filter.match?(a.name) } if filter
+
+        # Filter to enabled analyses
+        analyses = analyses.select { |a| analysis_enabled?(a) }
+
+        analyses.map { |analysis| execute(analysis) }
+      end
+
+      private
+
+      # Parse timeout string to seconds
+      # @param timeout_str [String, nil] Timeout string (e.g., "30s", "5m")
+      # @return [Integer] Timeout in seconds
+      def parse_timeout(timeout_str)
+        return DEFAULT_TIMEOUT if timeout_str.nil? || timeout_str.empty?
+
+        DURATION_PATTERNS.each do |pattern, multiplier|
+          match = timeout_str.match(pattern)
+          return match[1].to_i * multiplier if match
+        end
+
+        DEFAULT_TIMEOUT
+      end
+
+      # Check if analysis is enabled
+      # @param analysis [Object] Analysis instance
+      # @return [Boolean] true if enabled
+      def analysis_enabled?(analysis)
+        analysis.annotations["analysis/enabled"] != "false"
+      end
+    end
+  end
+end

data/lib/archsight/analysis/result.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Archsight
+  module Analysis
+    # Result represents the outcome of an Analysis execution
+    class Result
+      attr_reader :analysis, :success, :error, :error_backtrace, :sections, :duration
+
+      # @param analysis [Object] The Analysis resource that was executed
+      # @param success [Boolean] Whether execution completed successfully
+      # @param error [String, nil] Error message if execution failed
+      # @param error_backtrace [Array<String>, nil] Backtrace if execution failed
+      # @param sections [Array<Hash>] Output sections generated during execution
+      # @param duration [Float, nil] Execution duration in seconds
+      def initialize(analysis, success:, error: nil, error_backtrace: nil, sections: [], duration: nil)
+        @analysis = analysis
+        @success = success
+        @error = error
+        @error_backtrace = error_backtrace
+        @sections = sections || []
+        @duration = duration
+      end
+
+      # @return [Boolean] true if execution succeeded
+      def success?
+        @success
+      end
+
+      # @return [Boolean] true if execution failed
+      def failed?
+        !@success
+      end
+
+      # @return [String] Analysis name
+      def name
+        @analysis.name
+      end
+
+      # @return [Boolean] true if any content sections exist (excluding messages)
+      def has_findings?
+        @sections.any? { |s| %i[table list text heading code].include?(s[:type]) }
+      end
+
+      # @return [Integer] Count of error-level messages
+      def error_count
+        @sections.count { |s| s[:type] == :message && s[:level] == :error }
+      end
+
+      # @return [Integer] Count of warning-level messages
+      def warning_count
+        @sections.count { |s| s[:type] == :message && s[:level] == :warning }
+      end
+
+      # Convert result to markdown (only script-generated content)
+      # @param verbose [Boolean] Include detailed output
+      # @return [String] Markdown formatted output
+      def to_markdown(verbose: false)
+        format_sections_markdown(verbose).compact.join("\n\n")
+      end
+
+      # Render markdown for CLI display using tty-markdown
+      # @param verbose [Boolean] Include detailed output
+      # @return [String] Rendered output for terminal
+      def render(verbose: false)
+        require "tty-markdown"
+        md = to_markdown(verbose: verbose)
+        md.empty? ? "" : TTY::Markdown.parse(md)
+      rescue LoadError
+        # Fallback to plain markdown if tty-markdown not available
+        to_markdown(verbose: verbose)
+      end
+
+      # Format result for console output (backward compatible)
+      # @param verbose [Boolean] Include detailed output
+      # @return [String] Formatted output
+      def to_s(verbose: false)
+        render(verbose: verbose)
+      end
+
+      # Status emoji for display
+      # @return [String] Status emoji
+      def status_emoji
+        return "❌" unless success?
+
+        has_findings? ? "⚠️" : "✅"
+      end
+
+      # Formatted duration string
+      # @return [String] Duration string or empty
+      def duration_str
+        @duration ? format("%.2fs", @duration) : ""
+      end
+
+      # Error details as markdown (for CLI to use if needed)
+      # @param verbose [Boolean] Include backtrace
+      # @return [String, nil] Error markdown or nil
+      def error_markdown(verbose: false)
+        return nil unless failed?
+
+        lines = ["**Error:** #{@error}"]
+        if verbose && @error_backtrace&.any?
+          lines << ""
+          lines << "```"
+          lines.concat(@error_backtrace)
+          lines << "```"
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      def format_sections_markdown(verbose)
+        @sections.map { |section| format_section_markdown(section, verbose) }.compact
+      end
+
+      def format_section_markdown(section, verbose)
+        case section[:type]
+        when :message then format_message_markdown(section)
+        when :heading then format_heading_markdown(section)
+        when :text then section[:content]
+        when :table then format_table_markdown(section, verbose)
+        when :list then format_list_markdown(section, verbose)
+        when :code then format_code_markdown(section)
+        end
+      end
+
+      def format_message_markdown(section)
+        emoji = { error: "🔴", warning: "🟡", info: "🔵" }.fetch(section[:level], "ℹ️")
+        "#{emoji} #{section[:message]}"
+      end
+
+      def format_heading_markdown(section)
+        "#{"#" * (section[:level] + 1)} #{section[:text]}"
+      end
+
+      def format_table_markdown(section, verbose)
+        headers = section[:headers]
+        rows = section[:rows]
+
+        # Limit rows if not verbose
+        display_rows = verbose ? rows : rows.first(10)
+        truncated = !verbose && rows.size > 10
+
+        lines = []
+        lines << "| #{headers.join(" | ")} |"
+        lines << "| #{headers.map { "---" }.join(" | ")} |"
+        display_rows.each do |row|
+          lines << "| #{row.map { |cell| cell.to_s.gsub("|", "\\|") }.join(" | ")} |"
+        end
+        lines << "_...and #{rows.size - 10} more rows_" if truncated
+
+        lines.join("\n")
+      end
+
+      def format_list_markdown(section, verbose)
+        items = section[:items]
+
+        # Limit items if not verbose
+        display_items = verbose ? items : items.first(10)
+        truncated = !verbose && items.size > 10
+
+        lines = display_items.map { |item| "- #{item}" }
+        lines << "_...and #{items.size - 10} more items_" if truncated
+
+        lines.join("\n")
+      end
+
+      def format_code_markdown(section)
+        lang = section[:lang] || ""
+        "```#{lang}\n#{section[:content]}\n```"
+      end
+    end
+  end
+end