アクション

- name: Simple GET Request
  uses: http
  with:
    url: https://api.example.com/users
    method: GET
  test: res.code == 200

- name: Comprehensive HTTP Request
  uses: http
  timeout: 30s                                  # オプション: リクエストタイムアウト
  with:
    url: https://api.example.com/users/123        # 必須: ターゲット URL
    method: POST                                  # オプション: HTTP メソッド (デフォルト: GET)
    headers:                                      # オプション: リクエストヘッダー
      Content-Type: "application/json"
      Authorization: "Bearer {{vars.api_token}}"
      X-Request-ID: "{{random_str(16)}}"
    body: |                                       # オプション: リクエストボディ
      {
        "name": "John Doe",
        "email": "john@example.com",
        "active": true
      }
  test: res.code == 200 && res.body.success == true
  outputs:
    user_id: res.body.user.id
    created_at: res.body.user.created_at
    response_time: (rt.sec * 1000)

# 利用可能なレスポンスプロパティ:
test: |
  res.code == 200 &&                    # HTTP ステータスコード
  (rt.sec * 1000) < 1000 &&                      # レスポンス時間（ミリ秒）
  res.body_size < 10000 &&               # レスポンスボディサイズ（バイト）
  res.headers["Content-Type"] == "application/json" &&  # レスポンスヘッダー
  res.body.success == true &&            # 解析された JSON ボディ（該当する場合）
  res.body contains "success"           # テキストとしてのレスポンスボディ

jobs:
- id: api-test
  name: api-test
  steps:
    - name: Authenticate
      id: auth
      uses: http
      with:
        url: "{{vars.api_base_url}}/auth/login"
        method: POST
        headers:
          Content-Type: "application/json"
        body: |
          {
            "username": "{{vars.api_username}}",
            "password": "{{vars.api_password}}"
          }
      test: res.code == 200
      outputs:
        access_token: res.body.access_token
        refresh_token: res.body.refresh_token
 
    - name: Make Authenticated Request
      uses: http
      with:
        url: "{{vars.api_base_url}}/protected/resource"
        method: GET
        headers:
          Authorization: "Bearer {{outputs.auth.access_token}}"
      test: res.code == 200

- name: Upload File
  uses: http
  with:
    url: "{{vars.api_url}}/upload"
    method: POST
    headers:
      Content-Type: "multipart/form-data"
    body: |
      --boundary123
      Content-Disposition: form-data; name="file"; filename="test.txt"
      Content-Type: text/plain
      
      This is test file content
      --boundary123--
  test: res.code == 201

- name: GraphQL Query
  uses: http
  with:
    url: "{{vars.graphql_endpoint}}"
    method: POST
    headers:
      Content-Type: "application/json"
      Authorization: "Bearer {{vars.graphql_token}}"
    body: |
      {
        "query": "query GetUser($id: ID!) { user(id: $id) { name email active } }",
        "variables": { "id": "{{vars.test_user_id}}" }
      }
  test: res.code == 200 && res.body.data.user != null
  outputs:
    user_name: res.body.data.user.name
    user_email: res.body.data.user.email

- name: Build Application
  uses: shell
  with:
    cmd: "npm run build"
    workdir: "/app"
    timeout: "5m"
  test: res.code == 0

- name: Deploy Application
  uses: shell
  with:
    cmd: "./deploy.sh production"              # 必須: 実行するコマンド
    shell: "/bin/bash"                        # オプション: 使用するシェル (デフォルト: /bin/sh)
    workdir: "/deploy"                        # オプション: 作業ディレクトリ（絶対パス）
    timeout: "15m"                           # オプション: 実行タイムアウト（デフォルト: 30s）
    env:                                     # オプション: 環境変数
      DEPLOY_ENV: "production"
      API_KEY: "{{vars.production_api_key}}"
      BUILD_VERSION: "{{vars.version}}"
  test: res.code == 0 && res.stdout contains "Deploy successful"
  outputs:
    deploy_time: res.rt
    deploy_log: res.stdout

# 利用可能なレスポンスプロパティ:
test: |
  res.code == 0 &&                         # 終了コード（0 = 成功）
  res.stdout contains "success" &&        # 標準出力
  res.stderr == "" &&                      # 標準エラー（空 = エラーなし）
  req.cmd == "npm run build" &&           # 元のコマンド
  req.shell == "/bin/bash"                # 実行に使用されたシェル

jobs:
- id: build-and-test
  name: build-and-test
  steps:
    - name: Install Dependencies
      uses: shell
      with:
        cmd: "npm ci"
        workdir: "/app"
        timeout: "5m"
      test: res.code == 0
 
    - name: Run Tests
      uses: shell
      with:
        cmd: "npm test"
        workdir: "/app"
        env:
          NODE_ENV: "test"
          CI: "true"
      test: res.code == 0
 
    - name: Build Application
      uses: shell
      with:
        cmd: "npm run build"
        workdir: "/app"
        env:
          NODE_ENV: "production"
      test: res.code == 0

- name: Check System Health
  uses: shell
  with:
    cmd: |
      echo "=== System Health Report ===" &&
      echo "CPU Usage: $(top -bn1 | grep Cpu | cut -d' ' -f2)" &&
      echo "Memory: $(free -h | grep Mem)" &&
      echo "Disk: $(df -h /)"
  test: res.code == 0
  outputs:
    health_report: res.stdout

- name: Test Hello Action
  id: hello
  uses: hello
  with:
    message: "Test message"           # res にそのまま返る
  echo: "{{res.message}}"
  outputs:
    greeting: res.message

test: status == 0 && res.message != null

- name: Send Email Notification
  uses: smtp
  with:
    addr: "smtp.gmail.com              # SMTP サーバーホスト:587                         # SMTP サーバーポート"
    from: alerts@mycompany.com        # 送信者メールアドレス
    to: ["admin@mycompany.com", "team@mycompany.com"]  # 受信者
    subject: "System Alert: {{vars.alert_type}}"       # メール件名
    session: 1
    message: 1
    length: 500
  echo: |                           # メール本文（プレーンテキストまたは HTML）
  test: res.code == "sent"
  outputs:
    message_id: res.message_id
    recipients_count: res.recipients_count

with:
  host: smtp.gmail.com
  port: 587
  username: "your-email@gmail.com"
  password: "your-app-password"
  tls: true

with:
  host: email-smtp.us-east-1.amazonaws.com
  port: 587
  username: "{{vars.aws_ses_username}}"
  password: "{{vars.aws_ses_password}}"
  tls: true

with:
  host: smtp.office365.com
  port: 587
  username: "your-email@company.com"
  password: "{{vars.o365_password}}"
  tls: true

- name: "Service Health Check"
  uses: http
  with:
    method: GET
    url: "http://localhost:8080/health"
  retry:
    max_attempts: 10      # 最大試行回数
    interval: "2s"        # リトライ間隔
    initial_delay: "5s"   # 初回実行前の待機時間（オプション）
  test: res.code == 200

- name: "Wait for API Server"
  uses: http
  timeout: "5s"
  with:
    url: "{{vars.api_base_url}}/health"
    method: GET
  retry:
    max_attempts: 30
    interval: "2s"
    initial_delay: "10s"
  test: res.code == 200 && res.body.status == "healthy"

- name: "Wait for Database"
  uses: shell
  with:
    cmd: "pg_isready -h postgres -p 5432 -U app"
  retry:
    max_attempts: 60
    interval: "1s"
    initial_delay: "5s"
  test: res.code == 0

- name: "Database Connection Test"
  uses: db
  with:
    dsn: "postgres://user:pass@localhost:5432/testdb"
    query: "SELECT 1"
  retry:
    max_attempts: 20
    interval: "3s"
  test: res.code == 0

jobs:
- id: staged-startup
  name: staged-startup
  steps:
    - name: "Quick Health Check"
      uses: http
      with:
        method: GET
        url: "{{vars.service_url}}/ping"
      retry:
        max_attempts: 5
        interval: "100ms"
      test: res.code == 200
 
    - name: "Detailed Health Check"
      uses: http
      with:
        method: GET
        url: "{{vars.service_url}}/health"
      retry:
        max_attempts: 30
        interval: "2s"
        initial_delay: "1s"
      test: res.code == 200 && res.body.database_connected == true

- name: "Environment-Aware Health Check"
  uses: http
  with:
    method: GET
    url: "{{vars.service_url}}/health"
  retry:
    max_attempts: "{{vars.environment == 'production' ? 60 : 10}}"
    interval: "{{vars.environment == 'production' ? '5s' : '1s'}}"
  test: res.code == 200

# 良い例: リトライ間隔より短いタイムアウト
- name: "Quick API Check"
  uses: http
  timeout: "2s"        # 短いタイムアウト
  with:
    method: GET
    url: "{{vars.api_url}}/ping"
  retry:
    max_attempts: 10
    interval: "3s"       # タイムアウトより長い間隔

# 良い例: 合理的な試行回数
- name: "Service Startup"
  uses: shell
  with:
    cmd: "service myapp status"
  retry:
    max_attempts: 30     # 30回 × 2秒 = 最大1分待機
    interval: "2s"

# 良い例: サービス起動時間を考慮した初期遅延
- name: "Database Health Check"
  uses: db
  with:
    dsn: "{{vars.db_dsn}}"
    query: "SELECT 1"
  retry:
    max_attempts: 20
    interval: "3s"
    initial_delay: "15s"  # データベース起動に時間がかかる場合

jobs:
- id: resilient-http-check
  name: resilient-http-check
  steps:
    - name: Primary Endpoint Check
      id: primary
      uses: http
      timeout: 10s
      with:
        url: "{{vars.primary_url}}/health"
        method: GET
      test: res.code == 200
      outputs:
        primary_healthy: res.code == 200
        primary_response_time: (rt.sec * 1000)
 
    - name: Secondary Endpoint Check
      id: secondary
      uses: http
      timeout: 15s
      with:
        url: "{{vars.secondary_url}}/health"
        method: GET
      test: res.code == 200
      outputs:
        secondary_healthy: res.code == 200
        secondary_response_time: (rt.sec * 1000)
 
    - name: Alert on Total Failure
      uses: smtp
      with:
        addr: "{{vars.smtp_host}}:587"
        from: "alerts@company.com"
        to: "ops-team@company.com"
        subject: "CRITICAL: All endpoints down"
        session: 1
        message: 1
        length: 500
      echo: |
        CRITICAL ALERT: All monitored endpoints are down
          
        Primary Endpoint: FAILED
        Secondary Endpoint: FAILED
          
        Time: {{unixtime()}}
          
        Immediate investigation required!

jobs:
- id: comprehensive-api-test
  name: Comprehensive API Testing
  steps:
    # 1. ヘルスチェック
    - name: Verify API Health
      id: health
      uses: http
      with:
        method: GET
        url: "{{vars.api_url}}/health"
      test: res.code == 200
      outputs:
        api_version: res.body.version
        database_connected: res.body.database.connected
 
    # 2. 認証テスト
    - name: Test Authentication
      id: auth
      uses: http
      with:
        url: "{{vars.api_url}}/auth/token"
        method: POST
        headers:
          Content-Type: "application/json"
        body: |
          {
            "client_id": "{{vars.client_id}}",
            "client_secret": "{{vars.client_secret}}",
            "grant_type": "client_credentials"
          }
      test: res.code == 200
      outputs:
        access_token: res.body.access_token
        token_expires: res.body.expires_in
 
    # 3. 機能テスト
    - name: Test Core Functionality
      id: functional
      uses: http
      with:
        url: "{{vars.api_url}}/api/test"
        method: GET
        headers:
          Authorization: "Bearer {{outputs.auth.access_token}}"
      test: res.code == 200 && res.body.test_passed == true
      outputs:
        test_duration: (rt.sec * 1000)
        test_results: res.body.results
 
    # 4. パフォーマンス検証
    - name: Validate Performance
      uses: smtp
      with:
        addr: "{{vars.smtp_host}}:587"
        from: "performance@company.com"
        to: "dev-team@company.com"
        subject: "Performance Alert: Slow API Response"
        session: 1
        message: 1
        length: 500
      echo: |
        Performance Alert
          
        API Version: {{outputs.health.api_version}}
        Response Time: {{outputs.functional.test_duration}}ms
        Expected: < 2000ms
          
        Please investigate performance degradation.
 
        功通知
    - name: Success Report
      uses: hello
      echo: |
        ✅ API Test Suite Completed Successfully
          
        Health Check: ✅ (v{{outputs.health.api_version}})
        Authentication: ✅ (expires in {{outputs.auth.token_expires}}s)
        Functionality: ✅ ({{outputs.functional.test_duration}}ms)
        Performance: ✅ (within acceptable limits)

jobs:
- id: adaptive-monitoring
  name: adaptive-monitoring
  steps:
    - name: Determine Environment
      id: env
      uses: http
      with:
        method: GET
        url: "{{vars.config_service_url}}/environment"
      test: res.code == 200
      outputs:
        environment: res.body.environment
        notification_level: res.body.notifications.level
        smtp_config: res.body.smtp
 
    - name: Environment-Specific Health Check
      id: health
      uses: http
      timeout: "{{outputs.vars.environment == 'production' ? '5s' : '30s'}}"
      with:
        method: GET
        url: "{{vars.service_url}}/health"
      test: res.code == 200
      outputs:
        service_status: res.body.status
        error_count: res.body.errors
 
    - name: Conditional Alert
      uses: smtp
      with:
        addr: "{{outputs.vars.smtp_config.host}}:{{outputs.vars.smtp_config.port}}"
        from: "monitoring@company.com"
        to: "{{outputs.vars.environment == 'production' ? ['ops@company.com', 'management@company.com'] : ['dev@company.com']}}"
        subject: "{{outputs.vars.environment == 'production' ? 'PRODUCTION' : 'NON-PROD'}} Alert: Service Errors Detected"
        session: 1
        message: 1
        length: 500
      echo: |
        Service Error Alert
          
        Environment: {{outputs.vars.environment}}
        Service Status: {{outputs.health.service_status}}
        Error Count: {{outputs.health.error_count}}
          
        {{outputs.vars.environment == "production" ? "IMMEDIATE ACTION REQUIRED" : "Please investigate when convenient"}}

probe workflow.yml  # Stepが使う組み込みアクションを起動します
 
# 組み込みアクションに別途インストールは不要:
# http, db, shell, ssh, grpc, smtp, imap,
# dns, embedded, hello

# 良い例: 期待されるレスポンス時間に基づく具体的なタイムアウト
- name: Quick Health Check
  uses: http
  timeout: 5s              # クイックping は高速でレスポンスすべき
  with:
    method: GET
    url: "{{vars.api_url}}/ping"
 
- name: Complex Query
  uses: http
  timeout: 60s             # 複雑な操作にはより多くの時間が必要
  with:
    method: GET
    url: "{{vars.api_url}}/complex-report"

# 重要なアクション - 高速失敗
- name: Database Connectivity Check
  uses: http
  with:
    method: GET
    url: "{{vars.db_url}}/ping"
  test: res.code == 200
 
# 非重要なアクション - エラーでも継続
- name: Optional Analytics Update
  uses: http
  with:
    method: GET
    url: "{{vars.analytics_url}}/update"
  test: res.code == 200

# 良い例: シークレットに環境変数を使用
- name: Authenticated Request
  uses: http
  with:
    method: GET
    url: "{{vars.api_url}}/secure"
    headers:
      Authorization: "Bearer {{vars.api_token}}"  # vars から
 
# 良い例: 安全な SMTP 設定を使用
- name: Send Alert
  uses: smtp
  with:
    addr: "{{vars.smtp_host}}:25"
    from: "probe@example.com"
    to: "ops@example.com"
    session: 1
    message: 1
    length: 500
- name: Bad Example
  uses: http
  with:
    headers:
      Authorization: "Bearer secret-token-123"  # これは決してしてはいけません！

- name: Comprehensive API Test
  uses: http
  with:
    method: GET
    url: "{{vars.api_url}}/users"
  test: |
    res.code == 200 &&
    res.headers["Content-Type"] contains "application/json" &&
    res.body.users != null &&
    len(res.body.users) > 0 &&
    (rt.sec * 1000) < 1000
  outputs:
    user_count: len(res.body.users)
    response_time: (rt.sec * 1000)

- name: User Creation Test
  uses: http
  with:
    url: "{{vars.api_url}}/users"
    method: POST
    body: '{"name": "Test User", "email": "test@example.com"}'
  test: res.code == 201
  outputs:
    created_user_id: res.body.user.id
    created_user_email: res.body.user.email
    creation_timestamp: res.body.user.created_at
    response_time: (rt.sec * 1000)

type Action interface {
    Run(with map[string]any) (map[string]any, error)
}

type StepAction interface {
    Action
    RunStep(call Call) (result, newState map[string]any, err error)
}
 
type Call struct {
    With    map[string]any    // ステップのwithパラメータ
    State   map[string]any    // アクションがジョブに残した状態
    Step    Step              // 実行するステップ
    Guard   Guard             // 実行のガードがアクションに許可する操作
    Actions map[string]string // ワークフローのactionsで外部アクションに付けた名前
    Cleanups *Cleanups        // 実行の終わりにProbeが後始末をする場合はnilでない
    Processes *Processes      // アクションがバックグラウンドで動かし続けるプロセス
    Contract *Contract        // OpenAPIドキュメントなどの契約に対するステップの検証
}
 
type Step struct {
    RunID   string // probeの実行。すべてのステップで同じ
    JobID   string
    JobName string
    Index   int    // ジョブの中でのステップの位置（0から）
    ID      string
    Name    string
    Repeat  int    // 繰り返すジョブの何回目か（0から）
    Attempt int    // リトライするステップの何回目の試行か（1から）
}

type Cleaner interface {
    Action
    Cleanup(call CleanupCall) error
}
 
type CleanupCall struct {
    RunID string // 終わった実行。Step.RunIDと同じ値
}

- name: Ask the API who I am
  uses: github.com/mozership/probe-graphql@<40文字のコミットSHA>
  with:
    url: https://api.example.com/graphql
    query: '{ viewer { login } }'
  test: res.code == 200

actions:
  graphql: github.com/mozership/probe-graphql@<40文字のコミットSHA> # v0.2.0
 
jobs:
- name: Who am I
  defaults:
    graphql:
      url: https://api.example.com/graphql
  steps:
  - name: Ask the API who I am
    uses: graphql
    with:
      query: '{ viewer { login } }'
    test: res.code == 200

name: graphql
description: Send a GraphQL query over HTTP
guard: [read-only, allow-host]
params: [url, query, variables, operation_name, headers, timeout]
runs:
  using: binary
  url: https://github.com/mozership/probe-graphql/releases/download/v0.2.0/probe-graphql_{os}_{arch}
  checksums:
    darwin_amd64: <probe-graphql_darwin_amd64のSHA-256>
    darwin_arm64: <probe-graphql_darwin_arm64のSHA-256>
    linux_amd64: <probe-graphql_linux_amd64のSHA-256>
    linux_arm64: <probe-graphql_linux_arm64のSHA-256>

package main
 
import (
    "fmt"
    "time"
 
    "github.com/hashicorp/go-hclog"
    "github.com/mozership/probe/actionrpc"
)
 
// Greet は専用の実行ファイルで提供されるアクションです。
type Greet struct {
    log hclog.Logger
}
 
func (g *Greet) Run(with map[string]any) (map[string]any, error) {
    start := time.Now()
    actionrpc.LogParams(g.log, "greet received parameters", with)
 
    name, _ := with["name"].(string)
    return map[string]any{
        "req":    with,
        "res":    map[string]any{"message": fmt.Sprintf("Hello, %s!", name)},
        "rt":     time.Since(start).String(),
        "status": 0,
    }, nil
}
 
func main() {
    actionrpc.Serve(func(log hclog.Logger) actionrpc.Action {
        return &Greet{log: log}
    })
}

probe manifest v0.2.0 dist/checksums.txt > "$RUNNER_TEMP/action.yml"
cp "$RUNNER_TEMP/action.yml" action.yml

probe manifest init mozership/probe-greet > action.yml

runs:
  using: binary
  path: probe-greet

- name: Say hello
  uses: ./greet
  with:
    name: probe
  test: res.message == "Hello, probe!"

package main
 
import (
    "fmt"
    "os"
    "time"
 
    "github.com/hashicorp/go-hclog"
    "github.com/mozership/probe"
    "github.com/mozership/probe/actionrpc"
    "github.com/mozership/probe/actions"
)
 
// Greet は `uses: greet` で使うカスタムアクション
type Greet struct {
    log hclog.Logger
}
 
func (g *Greet) Run(with map[string]any) (map[string]any, error) {
    start := time.Now()
    actionrpc.LogParams(g.log, "greet received parameters", with)
 
    name, _ := with["name"].(string)
    return map[string]any{
        "req":    with,
        "res":    map[string]any{"message": fmt.Sprintf("Hello, %s!", name)},
        "rt":     time.Since(start).String(),
        "status": 0,
    }, nil
}
 
func main() {
    // Probe はアクションごとに、この実行ファイルを
    // `<実行ファイル> builtin-actions <名前>` として起動し直す
    if len(os.Args) == 3 && os.Args[1] == actionrpc.BuiltinCmd {
        name := os.Args[2]
        if name == "greet" {
            actionrpc.Serve(func(log hclog.Logger) actionrpc.Action {
                return &Greet{log: log}
            })
            return
        }
        if serve, ok := actions.Lookup(name); ok {
            serve()
            return
        }
        fmt.Fprintf(os.Stderr, "unknown action: %s\n", name)
        os.Exit(1)
    }
 
    p := probe.New(os.Args[1], false)
    if err := p.Do(); err != nil {
        fmt.Fprintln(os.Stderr, err)
    }
    os.Exit(p.ExitStatus())
}

- name: Say hello
  uses: greet
  with:
    name: probe
  test: res.message == "Hello, probe!"