action.yml

name: 'QtMeshEditor'
description: 'Validate, convert, and optimize 3D assets in CI. Scan for issues, convert 40+ formats, and more.'
author: 'Fernando Tonon'

branding:
  icon: 'box'
  color: 'blue'

inputs:
  command:
    description: 'Subcommand: scan, info, validate, convert, fix, anim, lod, pose'
    required: true
  input-file:
    description: 'Directory or file to scan (relative to workspace). Defaults to . (workspace root).'
    required: false
    default: '.'
  output-file:
    description: 'Output file path (for convert/fix/anim/pose)'
    required: false
  options:
    description: 'Additional CLI flags (e.g. --json, --fail-on warning, --resample 30)'
    required: false
  image-tag:
    description: 'ghcr.io/fernandotonon/qtmesh image tag. Pin to the same release as uses: ...@x.y.z so CLI matches the action (latest may lag or differ).'
    required: false
    default: 'latest'
  generate-badges:
    description: 'When command=scan, generate Shields endpoint badge JSON files from scan summary.'
    required: false
    default: 'false'
  badge-output-dir:
    description: 'Directory to write generated badge JSON files (workspace-relative or absolute).'
    required: false
    default: '.qtmesh-badges'
  badge-label-prefix:
    description: 'Badge label/prefix (default: qtmesh).'
    required: false
    default: 'qtmesh'
  badge-base-url:
    description: 'Public base URL hosting badge JSON files (used to expose ready-to-use badge URLs in outputs).'
    required: false
  qtmesh-token:
    description: 'Optional. Sets QTMESH_TOKEN in the container for QtMesh Cloud (same effect as CLI --token). Combine with qtmesh-no-upload / qtmesh-strict-upload or pass extra flags via options.'
    required: false
  qtmesh-api-base:
    description: 'Optional. Sets QTMESH_API_BASE (override API host, e.g. for self-hosted).'
    required: false
  qtmesh-no-upload:
    description: 'When true and command=scan, append --no-upload (skip cloud POST even if QTMESH_TOKEN is set).'
    required: false
    default: 'false'
  qtmesh-strict-upload:
    description: 'When true and command=scan, append --strict-upload (fail the job if cloud upload fails).'
    required: false
    default: 'false'

outputs:
  result:
    description: 'Command stdout (text or JSON depending on --json flag)'
    value: ${{ steps.run.outputs.result }}
  exit-code:
    description: 'Exit code (0 = success, 1 = issues found for scan/validate)'
    value: ${{ steps.run.outputs.exit-code }}
  badge-status:
    description: 'Computed scan status for generated badges: pass, warn, fail, or no-data.'
    value: ${{ steps.run.outputs.badge-status }}
  badge-directory:
    description: 'Directory where badge JSON files were generated.'
    value: ${{ steps.run.outputs.badge-directory }}
  badge-status-url:
    description: 'Shields endpoint URL for status badge (requires badge-base-url).'
    value: ${{ steps.run.outputs.badge-status-url }}
  badge-errors-url:
    description: 'Shields endpoint URL for errors badge (requires badge-base-url).'
    value: ${{ steps.run.outputs.badge-errors-url }}
  badge-warnings-url:
    description: 'Shields endpoint URL for warnings badge (requires badge-base-url).'
    value: ${{ steps.run.outputs.badge-warnings-url }}
  badge-passed-url:
    description: 'Shields endpoint URL for passed badge (requires badge-base-url).'
    value: ${{ steps.run.outputs.badge-passed-url }}
  badge-scanned-url:
    description: 'Shields endpoint URL for scanned badge (requires badge-base-url).'
    value: ${{ steps.run.outputs.badge-scanned-url }}
  badge-skipped-url:
    description: 'Shields endpoint URL for skipped badge (requires badge-base-url).'
    value: ${{ steps.run.outputs.badge-skipped-url }}

runs:
  using: 'composite'
  steps:
    - id: run
      shell: bash
      env:
        INPUT_COMMAND: ${{ inputs.command }}
        INPUT_FILE: ${{ inputs.input-file }}
        INPUT_OUTPUT_FILE: ${{ inputs.output-file }}
        INPUT_OPTIONS: ${{ inputs.options }}
        INPUT_GENERATE_BADGES: ${{ inputs.generate-badges }}
        INPUT_BADGE_OUTPUT_DIR: ${{ inputs.badge-output-dir }}
        INPUT_BADGE_LABEL_PREFIX: ${{ inputs.badge-label-prefix }}
        INPUT_BADGE_BASE_URL: ${{ inputs.badge-base-url }}
        INPUT_QTMESH_TOKEN: ${{ inputs.qtmesh-token }}
        INPUT_QTMESH_API_BASE: ${{ inputs.qtmesh-api-base }}
        INPUT_QTMESH_NO_UPLOAD: ${{ inputs.qtmesh-no-upload }}
        INPUT_QTMESH_STRICT_UPLOAD: ${{ inputs.qtmesh-strict-upload }}
      run: |
        set -o pipefail

        parse_metric_from_text() {
          local text="$1"
          local key="$2"
          printf '%s\n' "$text" | grep -Eo "${key}:[^0-9]*[0-9]+" | head -n1 | grep -Eo '[0-9]+$' || true
        }

        write_badge_json() {
          local target_file="$1"
          local label="$2"
          local message="$3"
          local color="$4"
          jq -n \
            --arg label "$label" \
            --arg message "$message" \
            --arg color "$color" \
            '{schemaVersion: 1, label: $label, message: $message, color: $color}' > "$target_file"
        }

        to_shields_endpoint_url() {
          local endpoint_json_url="$1"
          local encoded
          encoded=$(printf '%s' "$endpoint_json_url" | jq -sRr @uri)
          printf 'https://img.shields.io/endpoint?url=%s' "$encoded"
        }

        # Build command args safely via arrays to prevent injection
        if [ "$INPUT_COMMAND" = "scan" ]; then
          if [ -z "${INPUT_FILE:-}" ]; then
            INPUT_FILE="."
          fi
        else
          if [ -z "${INPUT_FILE:-}" ] || [ "${INPUT_FILE}" = "." ]; then
            echo "Error: input-file is required for command '$INPUT_COMMAND' (only scan defaults to '.')"
            exit 2
          fi
        fi

        cmd=("$INPUT_COMMAND" "/workspace/$INPUT_FILE")
        if [ -n "$INPUT_OUTPUT_FILE" ]; then
          cmd+=("-o" "/workspace/$INPUT_OUTPUT_FILE")
        fi
        if [ -n "$INPUT_OPTIONS" ]; then
          read -r -a opts <<< "$INPUT_OPTIONS"
          cmd+=("${opts[@]}")
        fi
        if [ "$INPUT_COMMAND" = "scan" ]; then
          if [ "${INPUT_QTMESH_NO_UPLOAD:-false}" = "true" ]; then
            cmd+=("--no-upload")
          fi
          if [ "${INPUT_QTMESH_STRICT_UPLOAD:-false}" = "true" ]; then
            cmd+=("--strict-upload")
          fi
        fi

        tmp_stdout=$(mktemp)
        tmp_stderr=$(mktemp)
        trap 'rm -f "$tmp_stdout" "$tmp_stderr"' EXIT

        docker_env=()
        if [ -n "${INPUT_QTMESH_TOKEN:-}" ]; then
          docker_env+=(--env "QTMESH_TOKEN=${INPUT_QTMESH_TOKEN}")
        fi
        # Same as CLI resolveIngestToken(): QTMESH_CLOUD_TOKEN is used if QTMESH_TOKEN is unset.
        # Forward from the workflow step/job env (set QTMESH_CLOUD_TOKEN on the calling step).
        if [ -n "${QTMESH_CLOUD_TOKEN:-}" ]; then
          docker_env+=(--env "QTMESH_CLOUD_TOKEN=${QTMESH_CLOUD_TOKEN}")
        fi
        if [ -n "${INPUT_QTMESH_API_BASE:-}" ]; then
          docker_env+=(--env "QTMESH_API_BASE=${INPUT_QTMESH_API_BASE}")
        fi
        # GitHub Actions sets these on the runner; forward into the container so uploads include
        # meta (repo, branch, sha, run id) for QtMesh Cloud dashboard / project linkage.
        for ga_name in GITHUB_REPOSITORY GITHUB_REF_NAME GITHUB_HEAD_REF GITHUB_BASE_REF GITHUB_SHA GITHUB_RUN_ID GITHUB_RUN_NUMBER GITHUB_WORKFLOW GITHUB_JOB GITHUB_ACTOR; do
          if [ -n "${!ga_name:-}" ]; then
            docker_env+=(--env "${ga_name}=${!ga_name}")
          fi
        done

        set +e
        docker run --rm \
          --user "$(id -u):$(id -g)" \
          -v "${{ github.workspace }}:/workspace" \
          "${docker_env[@]}" \
          "ghcr.io/fernandotonon/qtmesh:${{ inputs.image-tag }}" \
          "${cmd[@]}" >"$tmp_stdout" 2>"$tmp_stderr"
        EXIT_CODE=$?
        set -e

        STDOUT_OUTPUT=$(cat "$tmp_stdout")
        STDERR_OUTPUT=$(cat "$tmp_stderr")
        if [ -n "$STDOUT_OUTPUT" ] && [ -n "$STDERR_OUTPUT" ]; then
          OUTPUT="${STDOUT_OUTPUT}"$'\n'"${STDERR_OUTPUT}"
        elif [ -n "$STDOUT_OUTPUT" ]; then
          OUTPUT="$STDOUT_OUTPUT"
        else
          OUTPUT="$STDERR_OUTPUT"
        fi

        echo "result<<EOF" >> "$GITHUB_OUTPUT"
        echo "$OUTPUT" >> "$GITHUB_OUTPUT"
        echo "EOF" >> "$GITHUB_OUTPUT"
        echo "exit-code=$EXIT_CODE" >> "$GITHUB_OUTPUT"

        # Print output for workflow logs
        if [ -n "$STDOUT_OUTPUT" ]; then
          echo "$STDOUT_OUTPUT"
        fi
        if [ -n "$STDERR_OUTPUT" ]; then
          echo "$STDERR_OUTPUT" >&2
        fi

        if [ "${INPUT_GENERATE_BADGES}" = "true" ] && [ "$INPUT_COMMAND" = "scan" ]; then
          if ! command -v jq >/dev/null 2>&1; then
            echo "::warning::jq is required for badge generation, skipping."
          else
            scanned=""
            passed=""
            warnings=""
            errors=""
            skipped=""

            if printf '%s\n' "$STDOUT_OUTPUT" | jq -e '.summary | type == "object"' >/dev/null 2>&1; then
              scanned=$(printf '%s\n' "$STDOUT_OUTPUT" | jq -r '.summary.scanned // 0')
              passed=$(printf '%s\n' "$STDOUT_OUTPUT" | jq -r '.summary.passed // 0')
              warnings=$(printf '%s\n' "$STDOUT_OUTPUT" | jq -r '.summary.warnings // 0')
              errors=$(printf '%s\n' "$STDOUT_OUTPUT" | jq -r '.summary.errors // 0')
              skipped=$(printf '%s\n' "$STDOUT_OUTPUT" | jq -r '.summary.skipped // 0')
            else
              clean_output=$(printf '%s\n' "$OUTPUT" | sed -E 's/\x1B\[[0-9;]*[mK]//g')
              scanned=$(parse_metric_from_text "$clean_output" "Scanned")
              passed=$(parse_metric_from_text "$clean_output" "Passed")
              warnings=$(parse_metric_from_text "$clean_output" "Warnings")
              errors=$(parse_metric_from_text "$clean_output" "Errors")
              skipped=$(parse_metric_from_text "$clean_output" "Skipped")
            fi

            scanned=${scanned:-0}
            passed=${passed:-0}
            warnings=${warnings:-0}
            errors=${errors:-0}
            skipped=${skipped:-0}

            status="pass"
            status_color="brightgreen"
            if [ "$scanned" -eq 0 ]; then
              status="no-data"
              status_color="lightgrey"
            elif [ "$errors" -gt 0 ]; then
              status="fail"
              status_color="red"
            elif [ "$warnings" -gt 0 ]; then
              status="warn"
              status_color="yellow"
            fi

            badge_prefix="${INPUT_BADGE_LABEL_PREFIX:-qtmesh}"
            badge_dir="${INPUT_BADGE_OUTPUT_DIR:-.qtmesh-badges}"
            if [ "${badge_dir#/}" = "$badge_dir" ]; then
              badge_dir_abs="${{ github.workspace }}/${badge_dir}"
            else
              badge_dir_abs="${badge_dir}"
            fi
            mkdir -p "$badge_dir_abs"

            write_badge_json "$badge_dir_abs/${badge_prefix}-status.json" "$badge_prefix" "$status" "$status_color"
            write_badge_json "$badge_dir_abs/${badge_prefix}-errors.json" "${badge_prefix} errors" "$errors" "$( [ "$errors" -gt 0 ] && echo red || echo brightgreen )"
            write_badge_json "$badge_dir_abs/${badge_prefix}-warnings.json" "${badge_prefix} warnings" "$warnings" "$( [ "$warnings" -gt 0 ] && echo yellow || echo brightgreen )"
            write_badge_json "$badge_dir_abs/${badge_prefix}-passed.json" "${badge_prefix} passed" "$passed" "brightgreen"
            write_badge_json "$badge_dir_abs/${badge_prefix}-scanned.json" "${badge_prefix} scanned" "$scanned" "blue"
            write_badge_json "$badge_dir_abs/${badge_prefix}-skipped.json" "${badge_prefix} skipped" "$skipped" "lightgrey"

            echo "badge-status=$status" >> "$GITHUB_OUTPUT"
            echo "badge-directory=$badge_dir" >> "$GITHUB_OUTPUT"

            if [ -n "$INPUT_BADGE_BASE_URL" ]; then
              badge_base="${INPUT_BADGE_BASE_URL%/}"
              status_url=$(to_shields_endpoint_url "$badge_base/${badge_prefix}-status.json")
              errors_url=$(to_shields_endpoint_url "$badge_base/${badge_prefix}-errors.json")
              warnings_url=$(to_shields_endpoint_url "$badge_base/${badge_prefix}-warnings.json")
              passed_url=$(to_shields_endpoint_url "$badge_base/${badge_prefix}-passed.json")
              scanned_url=$(to_shields_endpoint_url "$badge_base/${badge_prefix}-scanned.json")
              skipped_url=$(to_shields_endpoint_url "$badge_base/${badge_prefix}-skipped.json")

              echo "badge-status-url=$status_url" >> "$GITHUB_OUTPUT"
              echo "badge-errors-url=$errors_url" >> "$GITHUB_OUTPUT"
              echo "badge-warnings-url=$warnings_url" >> "$GITHUB_OUTPUT"
              echo "badge-passed-url=$passed_url" >> "$GITHUB_OUTPUT"
              echo "badge-scanned-url=$scanned_url" >> "$GITHUB_OUTPUT"
              echo "badge-skipped-url=$skipped_url" >> "$GITHUB_OUTPUT"
            fi

            echo "Generated badges in: $badge_dir_abs"
          fi
        fi

        # Propagate exit code for scan/validate (exit 1 = issues found)
        exit $EXIT_CODE