### Development vs Production Credentials Example

Source: https://docs.autosana.ai/environments

Provides an example of how environment variables can be used to manage different credentials and API endpoints for development and production environments. A single hook script can then be used across both environments by referencing these variables.

```text
Log in with `{{TEST_EMAIL}}` and `{{TEST_PASSWORD}}`
Verify API connection to `{{API_URL}}`
```

--------------------------------

### JSON Configuration Examples for App Launch

Source: https://docs.autosana.ai/hooks

Provides examples of JSON payloads that can be used for app launch configuration, covering feature flag overrides, environment and timeout settings, A/B testing parameters, and debug mode options.

```json
{
  "featureFlags": {
    "newCheckoutFlow": "treatment_a",
    "paymentMethodV2": "enabled",
    "showPromotion": false
  }
}
```

```json
{
  "testEnvironment": "staging",
  "apiBaseUrl": "https://staging-api.example.com",
  "requestTimeout": 30,
  "retryAttempts": 3
}
```

```json
{
  "experiments": {
    "checkoutExperiment": "variant_b",
    "pricingExperiment": "control"
  },
  "userId": "test_user_123"
}
```

```json
{
  "enableDebugMode": true,
  "logLevel": "verbose",
  "showPerformanceMetrics": true,
  "mockPaymentProvider": true
}
```

--------------------------------

### Start Upload API

Source: https://docs.autosana.ai/api-ci

Initiate an app build upload and get a presigned URL for uploading your build file.

```APIDOC
## POST /api/ci/start-upload

### Description
Initiate an app build upload and get a presigned URL for uploading your build file.

### Method
POST

### Endpoint
/api/ci/start-upload

### Parameters
#### Request Body
- **bundle_id** (string) - Required - Your app's bundle identifier (e.g., `com.company.app`)
- **platform** (string) - Required - Target platform: `ios` or `android`
- **filename** (string) - Required - Name of the build file (e.g., `app-release.apk` or `MyApp.zip`)

### Request Example
```json
{
  "bundle_id": "com.company.app",
  "platform": "android",
  "filename": "app-release.apk"
}
```

### Response
#### Success Response (200)
- **upload_url** (string) - Presigned URL for uploading your build file via PUT request. Valid for 1 hour.
- **file_path** (string) - Storage path of the uploaded file. Pass this to the confirm-upload endpoint.

#### Response Example
```json
{
  "upload_url": "https://storage.supabase.co/...",
  "file_path": "app-uuid/android/app-release-20250115T103000.apk"
}
```
```

--------------------------------

### Authentication and Example Request

Source: https://docs.autosana.ai/api-reference

All API requests require an API key passed in the X-API-Key header. This example shows how to authenticate and create a new test suite.

```APIDOC
## Authentication

All API requests require an API key passed in the `X-API-Key` header.

### Method

POST

### Endpoint

`/api/v1/suites`

### Parameters

#### Header Parameters

- **X-API-Key** (string) - Required - Your organization's API key. Get it from your [Settings page](https://autosana.ai/settings).

#### Request Body

- **name** (string) - Required - The name of the test suite.

### Request Example

```bash
curl -X POST https://backend.autosana.ai/api/v1/suites \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "My Test Suite"}'
```

### Response

#### Success Response (200)

- **id** (string) - The unique identifier for the created test suite.
- **name** (string) - The name of the test suite.
- **created_at** (string) - The timestamp when the suite was created.

#### Response Example

```json
{
  "id": "suite_12345abc",
  "name": "My Test Suite",
  "created_at": "2023-10-27T10:00:00Z"
}
```
```

--------------------------------

### cURL: Creating a User Account with Environment Variables

Source: https://docs.autosana.ai/hooks

This cURL example shows how to create a user account by sending a POST request. It utilizes environment variables like `API_URL`, `ADMIN_TOKEN`, `TEST_EMAIL`, and `TEST_PASSWORD` for dynamic configuration.

```bash
curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${env:ADMIN_TOKEN}" \
  -d '{
    "email": "${env:TEST_EMAIL}",
    "password": "${env:TEST_PASSWORD}",
    "role": "tester"
  }'
```

--------------------------------

### Start App Build Upload Response (JSON)

Source: https://docs.autosana.ai/api-ci

Example JSON response from the /api/ci/start-upload endpoint. It contains the 'upload_url' for uploading the build file and the 'file_path' to be used in the confirm-upload endpoint.

```json
{
  "upload_url": "https://storage.supabase.co/…",
  "file_path": "app-uuid/android/app-release-20250115T103000.apk"
}
```

--------------------------------

### Start App Build Upload (Bash)

Source: https://docs.autosana.ai/api-ci

Initiates an app build upload by sending a POST request to the /api/ci/start-upload endpoint. It requires the app's bundle ID, platform, and filename. The response provides a presigned URL for uploading the build file.

```bash
curl -X POST https://backend.autosana.ai/api/ci/start-upload \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "bundle_id": "com.company.app",
    "platform": "android",
    "filename": "app-release.apk"
  }'
```

--------------------------------

### Python Setup Hook for Authentication

Source: https://docs.autosana.ai/hooks

This Python script demonstrates how to set up an authentication hook. It sends login credentials from environment variables to an API, parses the JSON response, and prints relevant user information. The printed output is automatically passed to the agent as context.

```python
import urllib.request
import json
import os

data = json.dumps({
    "email": os.environ.get('TEST_EMAIL'),
    "password": os.environ.get('TEST_PASSWORD')
}).encode('utf-8')

req = urllib.request.Request(
    f"{os.environ.get('API_URL')}/auth/login",
    data=data,
    headers={'Content-Type': 'application/json'}
)

with urllib.request.urlopen(req) as response:
    result = json.loads(response.read().decode('utf-8'))

# This output is passed to the agent
print(f"Logged in as: {result['email']}")
print(f"User role: {result['role']}")
print(f"Account created: {result['createdAt']}")
```

--------------------------------

### Feature Flags Example with Environment Variables

Source: https://docs.autosana.ai/environments

Shows a practical application of environment variables for managing feature flags across different deployment stages. This allows for enabling or disabling features based on the environment's configuration.

```text
Open settings
Enable experimental mode if `{{EXPERIMENTAL_MODE}}` is "enabled"
Verify new checkout is `{{FEATURE_NEW_CHECKOUT}}`
```

--------------------------------

### Build Android App with Fastlane and Autosana

Source: https://docs.autosana.ai/ci-cd-integration

This example demonstrates building an Android application using Fastlane and the autosana-ci action. It includes steps for checking out code, setting up Java and Ruby environments, and then running the Fastlane build command. The autosana-ci action requires an API key, bundle ID, platform set to 'android', and the path to the built APK.

```yaml
name: Fastlane Android + Autosana

on:
  push:
    branches: [ main ]

jobs:
  build-and-test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK
        uses: actions/setup-java@v3
        with:
          java-version: '11'
          distribution: 'temurin'

      - name: Set up Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.0'
          bundler-cache: true

      - name: Build with Fastlane
        run: bundle exec fastlane android build

      - uses: autosana/autosana-ci@main
        with:
          api-key: ${{ secrets.AUTOSANA_KEY }}
          bundle-id: com.example.app # TODO: Replace with your bundle ID
          platform: android
          build-path: ./app/build/outputs/apk/release/app-release.apk
```

--------------------------------

### cURL: Generating an Authentication Token

Source: https://docs.autosana.ai/hooks

This cURL example shows how to generate an authentication token by sending a POST request with client credentials. It uses environment variables for `CLIENT_ID` and `CLIENT_SECRET`.

```bash
curl -X POST https://api.example.com/auth/token \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "${env:CLIENT_ID}",
    "client_secret": "${env:CLIENT_SECRET}"
  }'
```

--------------------------------

### Authenticate and Set Token (Bash)

Source: https://docs.autosana.ai/hooks

This Bash script authenticates with an API using provided credentials, extracts the authentication token and user ID from the response, and exports them to a temporary environment file for subsequent use. It requires `curl` and `jq` to be installed.

```bash
RESPONSE=$(curl -s -X POST "${API_URL}/auth/login" \
  -H "Content-Type: application/json" \
  -d "{\"email\":\"${TEST_EMAIL}\",\"password\":\"${TEST_PASSWORD}\"}")

TOKEN=$(echo $RESPONSE | jq -r '.token')
USER_ID=$(echo $RESPONSE | jq -r '.userId')

echo "Logged in as user: $USER_ID"

# Export token for subsequent hooks (append with >>)
echo "AUTH_TOKEN=$TOKEN" >> /tmp/autosana.env
```

--------------------------------

### iOS Bundle ID Example

Source: https://docs.autosana.ai/bundle-id

This is an example of a typical Bundle ID for an iOS application. The Bundle ID is a unique string that identifies your app on the App Store.

```text
com.yourcompany.yourapp
```

--------------------------------

### Example Error Response

Source: https://docs.autosana.ai/api-reference

Illustrates a typical JSON error response from the Autosana API. This format is used for various error conditions, such as resource not found.

```json
{
  "detail": "Suite not found"
}
```

--------------------------------

### List Suites

Source: https://docs.autosana.ai/api-suites-flows

Retrieves a list of all test suites associated with your organization. This endpoint is useful for getting an overview of existing test suites.

```APIDOC
## GET /api/v1/suites

### Description
Get all test suites for your organization.

### Method
GET

### Endpoint
/api/v1/suites

### Parameters
#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **suites** (array) - List of suite objects. Each suite object contains:
  - **id** (string) - Unique identifier (UUID)
  - **name** (string) - Name of the suite
  - **description** (string | null) - Description of what the suite tests
  - **created_at** (string) - ISO 8601 timestamp of when the suite was created
- **count** (integer) - Total number of suites returned

#### Response Example
```json
{
  "suites": [
    {
      "id": "550e8400-e29b-41d4-a716-446655440000",
      "name": "Login Feature Tests",
      "description": "Tests for user authentication",
      "created_at": "2025-01-15T10:30:00Z"
    },
    {
      "id": "550e8400-e29b-41d4-a716-446655440001",
      "name": "Checkout Flow Tests",
      "description": null,
      "created_at": "2025-01-14T09:00:00Z"
    }
  ],
  "count": 2
}
```
```

--------------------------------

### Build iOS Release App for Simulator using Terminal

Source: https://docs.autosana.ai/app-build-guide

This command builds the Release version of an iOS app for the simulator. It specifies the SDK, configuration, destination, and disables code signing for simulator builds. The output is an .app file.

```bash
cd /path/to/your/project
xcodebuild -scheme YourAppScheme \
  -sdk iphonesimulator \
  -configuration Release \
  -destination 'platform=iOS Simulator,OS=latest,name=iPhone 16 Pro' \
  -derivedDataPath ./build \
  ARCHS=arm64 \
  ONLY_ACTIVE_ARCH=NO \
  CODE_SIGN_IDENTITY="" \
  CODE_SIGNING_REQUIRED=NO \
  CODE_SIGNING_ALLOWED=NO \
  build
```

--------------------------------

### Confirm App Build Upload Response (JSON)

Source: https://docs.autosana.ai/api-ci

Example JSON response from the /api/ci/confirm-upload endpoint. It indicates the 'status' of the upload, provides a 'message', and the number of 'triggered_flows' (automations).

```json
{
  "status": "success",
  "message": "App build uploaded successfully",
  "triggered_flows": 3
}
```

--------------------------------

### Build Native iOS App for Simulator using Xcode

Source: https://docs.autosana.ai/app-build-guide

Builds a native iOS application for the simulator using Xcode. This process involves setting the build configuration to 'Release' and then building the project. The output .app file is located within the Xcode DerivedData directory.

```bash
~/Library/Developer/Xcode/DerivedData/<ProjectName>/Build/Products/Release-iphonesimulator/<AppName>.app

```

--------------------------------

### Basic cURL POST Request

Source: https://docs.autosana.ai/hooks

A simple cURL command to perform a POST request to a specified API endpoint with JSON data. This is a foundational example for making API calls.

```bash
curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -d '{"email":"test@example.com","password":"TestPass123"}'
```

--------------------------------

### Configure Weekly Comprehensive Suite Automation

Source: https://docs.autosana.ai/automations

This configuration defines a 'Weekly Comprehensive Suite' automation that runs every Friday at 6:00 PM. It includes 'Full Regression', 'Edge Cases', and 'Performance Flows' suites and is not restricted to running only on new builds.

```text
Name: "Weekly Comprehensive Suite"
Trigger: Friday at 6:00 PM
Suites: ["Full Regression", "Edge Cases", "Performance Flows"]
Only run on new builds: No
```

--------------------------------

### Access Environment Variables in Scripts

Source: https://docs.autosana.ai/hooks

Provides examples of how to access environment variables within different scripting languages (Python, JavaScript/TypeScript, Bash). These variables are automatically injected into the script's execution environment.

```python
import os

api_url = os.environ.get('API_URL')
test_email = os.getenv('TEST_EMAIL')
```

```javascript
const apiUrl = process.env.API_URL;
const testEmail = process.env.TEST_EMAIL;
```

```bash
echo $API_URL
echo ${TEST_EMAIL}
```

--------------------------------

### Build React Native Release App for iOS Simulator

Source: https://docs.autosana.ai/app-build-guide

Builds a React Native application for the iOS simulator in Release mode. This command is executed from the project's root directory. The resulting .app file is typically found in the 'ios/build/Products/Release-iphonesimulator' directory.

```bash
npx react-native run-ios --mode Release

```

--------------------------------

### Configure Hourly Smoke Check Automation

Source: https://docs.autosana.ai/automations

This configuration sets up an automation named 'Hourly Smoke Check' that triggers every 2 hours, starting at 8:00 AM PT. It is designed to run on the 'Critical Path Flows' suite and is configured to only run on new builds.

```text
Name: "Hourly Smoke Check"
Trigger: Every 2 hours, starting at 8:00 AM PT
Suites: ["Critical Path Flows"]
Only run on new builds: Yes
```

--------------------------------

### Configure Nightly Regression Automation

Source: https://docs.autosana.ai/automations

This configuration sets up a daily 'Nightly Regression' automation that runs at 2:00 AM. It executes the comprehensive 'Full Regression' suite and is enabled to only run on new builds.

```text
# Automation 2
Name: "Nightly Regression"
Trigger: Daily at 2:00 AM
Suites: ["Full Regression"]
Only run on new builds: Yes
```

--------------------------------

### cURL: Using Exported Environment Variables

Source: https://docs.autosana.ai/hooks

This cURL command illustrates how to access environment variables previously exported by a setup hook. It uses the `${env:VARIABLE_NAME}` syntax to include the `API_URL` and `AUTH_TOKEN` in the request headers and URL.

```bash
curl -X POST ${env:API_URL}/cart/add \
  -H "Authorization: Bearer ${env:AUTH_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{"productId": "12345", "quantity": 1}'
```

--------------------------------

### Fetch and Process Products Data (JavaScript)

Source: https://docs.autosana.ai/hooks

Fetches product data from an API, finds an in-stock product under a certain price, logs its details, and exports its ID to an environment file. Requires API URL and token from environment variables.

```javascript
const response = await fetch(`${process.env.API_URL}/products`, {
  headers: { 'Authorization': `Bearer ${process.env.API_TOKEN}` }
});

const products = await response.json();

// Find a product that's in stock
const availableProduct = products.find(p => p.inStock && p.price < 100);

if (availableProduct) {
  console.log(`Found product: ${availableProduct.name} ($${availableProduct.price})`);

  // Export for use in flow
  const fs = require('fs');
  fs.writeFileSync('/tmp/autosana.env', `TEST_PRODUCT_ID=${availableProduct.id}\n`);
} else {
  throw new Error('No suitable test product found');
}
```

--------------------------------

### Create Test Suite using cURL

Source: https://docs.autosana.ai/api-reference

Demonstrates how to create a new test suite using a cURL command. This requires an API key for authentication and specifies the suite name in JSON format.

```bash
curl -X POST https://backend.autosana.ai/api/v1/suites \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "My Test Suite"}'
```

--------------------------------

### Build Android Release APK using Terminal

Source: https://docs.autosana.ai/app-build-guide

This command builds a release APK for an Android application using Gradle. It navigates to the project directory and executes the assembleRelease task. The output is a release APK file, suitable for production-like testing.

```bash
cd /path/to/your/android/project
./gradlew assembleRelease
```

--------------------------------

### Add Autosana Docs MCP Server via Claude CLI

Source: https://docs.autosana.ai/mcp-setup

This command adds the Autosana Docs MCP server to your Claude CLI configuration. It specifies the transport protocol as HTTP and provides the server URL. Ensure you have the Claude CLI installed and configured.

```bash
claude mcp add --transport http autosana-docs https://docs.autosana.ai/mcp
```

--------------------------------

### Build and Upload Native Android App with Autosana

Source: https://docs.autosana.ai/ci-cd-integration

This YAML snippet details how to build a native Android application and upload it using the autosana-ci action. It runs on an Ubuntu latest runner and includes a placeholder for the specific Android build command (e.g., Gradle, Flutter, React Native). The autosana-ci action requires the API key, bundle ID, platform set to 'android', and the path to the generated APK.

```yaml
name: Build and Upload to Autosana (Android)

on:
  push:
    branches: [ main ]

jobs:
  build-and-upload:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      # TODO: Build your Android app
      # Examples:
      # - ./gradlew assembleRelease
      # - flutter build apk --release
      # - react-native run-android --variant=release

      - uses: autosana/autosana-ci@main
        with:
          api-key: ${{ secrets.AUTOSANA_KEY }}
          bundle-id: com.example.app # TODO: Replace with your app's bundle ID
          platform: android
          build-path: app/build/outputs/apk/release/app-release.apk # TODO: Update path
```

--------------------------------

### Configure Autosana MCP Servers in Claude Desktop

Source: https://docs.autosana.ai/mcp-setup

This JSON configuration adds both Autosana Docs and Autosana Agent MCP servers to your Claude Desktop. It specifies the URLs for each server and includes the 'x-api-key' header for the Autosana Agent. Update the '~/claude_desktop_config.json' file with this content, replacing '<YOUR_API_KEY>' with your actual API key.

```json
{
  "mcpServers": {
    "autosana-docs": {
      "url": "https://docs.autosana.ai/mcp"
    },
    "autosana": {
      "url": "https://mcp.autosana.ai/mcp",
      "headers": {
        "x-api-key": "<YOUR_API_KEY>"
      }
    }
  }
}
```

--------------------------------

### Create Test Suite (Bash)

Source: https://docs.autosana.ai/api-suites-flows

Creates a new test suite with a specified name and an optional description. Requires an API key and JSON content type in the request headers. The response includes details of the newly created suite.

```bash
curl -X POST https://backend.autosana.ai/api/v1/suites \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "JIRA-1234: User Authentication",
    "description": "Auto-generated tests for login feature"
  }'
```

--------------------------------

### Android Application ID from Google Play Store URL

Source: https://docs.autosana.ai/bundle-id

This text example illustrates how to extract the Application ID from a Google Play Store URL. The `id` parameter in the URL query string represents the app's unique identifier.

```text
https://play.google.com/store/apps/details?id=org.wikipedia&hl=en_US
```

--------------------------------

### Build Flutter App for iOS Simulator

Source: https://docs.autosana.ai/app-build-guide

Builds a Flutter application specifically for the iOS simulator. This command generates a .app file. If your app uses flavors, include the --flavor flag followed by your flavor name.

```bash
flutter build ios --simulator

```

```bash
flutter build ios --simulator --flavor [flavorName]

```

--------------------------------

### Expo EAS Android Build with Autosana CI

Source: https://docs.autosana.ai/ci-cd-integration

Configures an Android build using Expo EAS and integrates it with Autosana CI. Requires `eas.json` configuration for Android builds and a GitHub Actions workflow that mirrors the iOS setup but targets the Android platform.

```json
{
  "build": {
    "preview": {
      "distribution": "internal",
      "android": {
        "buildType": "apk"
      }
    }
  }
}
```

```yaml
name: EAS Android Build + Autosana

on:
  push:
    branches:
      - main
  workflow_dispatch:

jobs:
  build-and-test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
          cache: 'npm'

      - name: Set up Expo and EAS
        uses: expo/expo-github-action@v8
        with:
          eas-version: latest
          token: ${{ secrets.EXPO_TOKEN }}

      - name: Install dependencies
        run: npm install

      - name: Run Android Build
        run: eas build --platform android --profile preview --non-interactive --wait --json > build-info.json

      - name: Download APK from EAS
        run: |
          BUILD_URL=$(jq -r '.[0].artifacts.buildUrl' build-info.json)
          echo "Downloading APK from $BUILD_URL"
          curl -L "$BUILD_URL" -o app.apk

      - name: Run Autosana CI
        uses: autosana/autosana-ci@main
        with:
          api-key: ${{ secrets.AUTOSANA_KEY }}
          bundle-id: YOUR_BUNDLE_ID # TODO: Replace with your bundle ID
          platform: android
          build-path: app.apk

```

--------------------------------

### AI Agent Prompt for CI/CD Workflow Generation

Source: https://docs.autosana.ai/ci-cd-integration

This prompt guides AI agents in scanning a repository, understanding project structure, build commands, and environments to generate appropriate CI/CD workflow files for Autosana MCP. It specifies the initial content and required Autosana GitHub Actions script.

```markdown
Scan the repo to understand the project and how it is built. You should determine things like:
1. The project type (react-native, flutter, android-native, ios-native, etc)
2. Supported platforms (android, ios, or both)
3. Existing Github workflow files, if any
4. The correct build commands and configurations, indicated by the presence of Fastlane, EAS, etc... It can also help to look for .md files that explain the build process.
5. Available environments (development, staging, production, etc) and how they are configured

Create a plan for how to build the app. Then, generate a complete autosana-ios.yml and autosana-android.yml (whatever platforms are applicable) file, in .github/workflows. Use the best approach for the project (Fastlane, EAS, native, etc).

Unless specified otherwise by the user, the file(s) should start with the following:
name: Autosana (platform) App Upload
on:
  workflow_dispatch:
  push:
    branches:
      - (primary branch)
  pull_request:
    branches:
      - (primary branch)

The file MUST contain the following Autosana Github Actions script at the end:
- uses: autosana/autosana-ci@main
  with:
    api-key: ${{ secrets.AUTOSANA_KEY }}
    bundle-id: com.example.app # TODO: Replace with your bundle ID
    platform: ios/android
    build-path: ./build/MyApp.app # TODO: Replace with your build path

Important requirements:
- For Android, always target universal APK architecture for emulator compatibility
- For iOS, always build for simulator, not physical device
- Include actual paths based on common conventions for the detected framework
- Prefer the staging environment, if available (and not specified otherwise by the user)
- For EAS iOS builds, you can use a linux runner if doing cloud builds

Finally, once implemented, thoroughly review the script(s) to ensure it is correct before it's run.
It is critical that the script(s) will run successfully.
```

--------------------------------

### Upload Build File (Bash)

Source: https://docs.autosana.ai/api-ci

Uploads the actual app build file to the presigned URL obtained from the start-upload endpoint using a PUT request. The Content-Type should be application/octet-stream.

```bash
curl -X PUT "UPLOAD_URL_FROM_RESPONSE" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @./path/to/your/app.apk
```

--------------------------------

### Example API Response: List of Flows (JSON)

Source: https://docs.autosana.ai/api-suites-flows

This JSON object represents a typical response when retrieving a list of test flows from the Autosana AI API. It includes an array of flow objects, each with details like ID, name, description, and creation timestamp, along with a count of the total flows.

```json
{
  "flows": [
    {
      "id": "660e8400-e29b-41d4-a716-446655440001",
      "name": "Login with valid credentials",
      "description": "Positive test case",
      "instructions": "Enter valid email and password, tap login, verify home screen",
      "type": "single-prompt",
      "caching_enabled": true,
      "created_at": "2025-01-15T10:31:00Z"
    },
    {
      "id": "660e8400-e29b-41d4-a716-446655440002",
      "name": "Login with invalid password",
      "description": "Negative test case",
      "instructions": "Enter valid email but wrong password, verify error message",
      "type": "single-prompt",
      "caching_enabled": true,
      "created_at": "2025-01-15T10:32:00Z"
    }
  ],
  "count": 2
}
```

--------------------------------

### Configure Continuous Monitoring Automation

Source: https://docs.autosana.ai/automations

This configuration sets up a 'Continuous Monitoring' automation designed to run critical flows every 2 hours. It is set to only execute on new builds to ensure efficient resource utilization.

```text
Name: "Continuous Monitoring"
Trigger: Every 2 hours
Suites: ["Critical Path Flows"]
Only run on new builds: Yes
```

--------------------------------

### Create Test Flows with cURL

Source: https://docs.autosana.ai/api-suites-flows

This section shows how to create individual test flows (test cases) and associate them with a previously created suite. It includes examples for both positive and negative test scenarios, specifying the suite ID and detailed instructions for each flow. This requires the suite ID obtained from the previous step.

```bash
# Positive test case
curl -X POST https://backend.autosana.ai/api/v1/flows \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Login with valid credentials",
    "instructions": "Enter valid email and password, tap login, verify home screen appears",
    "suite_id": "SUITE_ID_FROM_STEP_1"
  }'

# Negative test case
curl -X POST https://backend.autosana.ai/api/v1/flows \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Login with invalid password",
    "instructions": "Enter valid email but wrong password, tap login, verify error message appears",
    "suite_id": "SUITE_ID_FROM_STEP_1"  }'
```