tavus-cli 0.3.3__tar.gz → 0.4.0__tar.gz

{tavus_cli-0.3.3 → tavus_cli-0.4.0}/.github/workflows/ci.yml

@@ -5,6 +5,7 @@ on:
   push:
     branches:
       - main
+  workflow_dispatch:
 
 concurrency:
   group: ci-${{ github.ref }}
@@ -25,6 +26,8 @@ jobs:
           python-version: ${{ matrix.python-version }}
       - name: Install uv
         run: pip install uv
+      - name: Check release versions before dependency sync
+        run: python scripts/check_release_versions.py
       - name: Install dependencies
         run: uv sync --extra dev
       - name: Ruff

tavus_cli-0.4.0/.github/workflows/deploy-cloudflare-worker.yml

@@ -0,0 +1,102 @@
+name: Deploy Tavus MCP Worker to a lower environment
+
+on:
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: Lower environment to deploy
+        required: true
+        default: stg
+        type: choice
+        options:
+          - test
+          - stg
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+  deployments: read
+  pull-requests: read
+
+concurrency:
+  group: deploy-tavus-mcp-worker-${{ github.event_name == 'workflow_dispatch' && inputs.environment || 'stg' }}
+  cancel-in-progress: true
+
+jobs:
+  deploy:
+    name: Deploy Worker to ${{ github.event_name == 'workflow_dispatch' && inputs.environment || 'stg' }}
+    # A release commit is the small version/changelog delta on top of the code
+    # already proven in staging. The release workflow promotes that exact tag.
+    if: >-
+      github.event_name == 'workflow_dispatch' ||
+      !startsWith(github.event.head_commit.message, 'chore(main): release')
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    environment: ${{ github.event_name == 'workflow_dispatch' && inputs.environment || 'stg' }}
+    env:
+      CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+      CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+      CLOUDFLARE_ENV: ${{ github.event_name == 'workflow_dispatch' && inputs.environment || 'stg' }}
+      MCP_BASE_URL: https://mcp.tavus-preview.io
+    defaults:
+      run:
+        working-directory: workers/tavus-mcp
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+          cache-dependency-path: workers/tavus-mcp/package-lock.json
+
+      - name: Validate deployment secrets
+        run: |
+          if [ -z "${CLOUDFLARE_API_TOKEN:-}" ]; then
+            echo "::error::Missing CLOUDFLARE_API_TOKEN for '$CLOUDFLARE_ENV'."
+            exit 1
+          fi
+          if [ -z "${CLOUDFLARE_ACCOUNT_ID:-}" ]; then
+            echo "::error::Missing CLOUDFLARE_ACCOUNT_ID for '$CLOUDFLARE_ENV'."
+            exit 1
+          fi
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Type-check
+        run: npm run build
+
+      - name: Test
+        run: npm test
+
+      - name: Deploy Worker
+        run: npx wrangler deploy --env "$CLOUDFLARE_ENV"
+
+      - name: Smoke-test hosted OAuth and MCP routes
+        if: env.CLOUDFLARE_ENV == 'stg'
+        run: |
+          curl --fail --silent --show-error \
+            "$MCP_BASE_URL/.well-known/oauth-protected-resource/mcp" >/dev/null
+          curl --fail --silent --show-error \
+            "$MCP_BASE_URL/.well-known/oauth-authorization-server" >/dev/null
+          STATUS=$(curl --silent --output /tmp/tavus-mcp-response \
+            --write-out '%{http_code}' "$MCP_BASE_URL/mcp")
+          if [ "$STATUS" != "401" ]; then
+            echo "::error::$MCP_BASE_URL/mcp returned $STATUS; expected 401 without credentials."
+            cat /tmp/tavus-mcp-response
+            exit 1
+          fi
+
+      - name: Refresh Slack deployment tabs
+        if: always() && env.CLOUDFLARE_ENV == 'stg'
+        continue-on-error: true
+        uses: Tavus-Engineering/pr-changelog-action/status@main
+        with:
+          slack-bot-token: ${{ secrets.CVI_BOT_SLACK_TOKEN }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}

tavus_cli-0.4.0/.github/workflows/pypi-cli.yml

@@ -0,0 +1,382 @@
+name: Release Tavus MCP
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Existing GitHub release tag to retry, such as v0.3.4
+        required: true
+        type: string
+
+permissions:
+  actions: write
+  contents: write
+  deployments: read
+  id-token: write
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: release-tavus-mcp
+  cancel-in-progress: false
+
+jobs:
+  release-please:
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
+    steps:
+      - name: Open or publish the release
+        id: release
+        uses: googleapis/release-please-action@v4.4.1
+        with:
+          token: ${{ github.token }}
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+
+      # release-please's generic TOML updater cannot target one package in
+      # uv.lock's [[package]] array. Re-lock the generated release branch so
+      # the local tavus-cli package matches pyproject.toml before CI runs.
+      - name: Checkout the release pull request
+        if: steps.release.outputs.prs_created == 'true'
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ fromJSON(steps.release.outputs.pr).headBranchName }}
+          fetch-depth: 0
+
+      - name: Set up Python for the release lockfile
+        if: steps.release.outputs.prs_created == 'true'
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install uv for the release lockfile
+        if: steps.release.outputs.prs_created == 'true'
+        run: pip install uv
+
+      - name: Refresh the release lockfile
+        if: steps.release.outputs.prs_created == 'true'
+        run: |
+          set -euo pipefail
+          uv lock
+          if git diff --quiet -- uv.lock; then
+            echo "uv.lock already matches the release version."
+            exit 0
+          fi
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add uv.lock
+          git commit -m "chore: refresh the release lockfile"
+          git push
+
+      # Pull requests created with GITHUB_TOKEN do not emit pull_request
+      # events. Dispatch both checks against the generated branch so its head
+      # still gets the normal CI and exact-staging evidence.
+      - name: Run checks for the release pull request
+        if: steps.release.outputs.prs_created == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_PR: ${{ steps.release.outputs.pr }}
+        run: |
+          set -euo pipefail
+          BRANCH=$(jq -r '.headBranchName // empty' <<<"$RELEASE_PR")
+          NUMBER=$(jq -r '.number // empty' <<<"$RELEASE_PR")
+          if [[ ! "$BRANCH" =~ ^release-please ]]; then
+            echo "::error::Unexpected release pull request branch '$BRANCH'."
+            exit 1
+          fi
+          echo "Dispatching checks for release pull request #$NUMBER on $BRANCH."
+          gh workflow run ci.yml --repo "${{ github.repository }}" --ref "$BRANCH"
+          gh workflow run validate-staging-deployment.yml \
+            --repo "${{ github.repository }}" \
+            --ref "$BRANCH" \
+            -f main_sha="${{ github.sha }}"
+
+      - name: Refresh Slack deployment tabs
+        continue-on-error: true
+        uses: Tavus-Engineering/pr-changelog-action/status@main
+        with:
+          slack-bot-token: ${{ secrets.CVI_BOT_SLACK_TOKEN }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+  preflight:
+    name: Validate and build the exact release tag
+    needs: release-please
+    if: >-
+      always() &&
+      (github.event_name == 'workflow_dispatch' ||
+      needs.release-please.outputs.release_created == 'true')
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    env:
+      RELEASE_TAG: ${{ github.event_name == 'workflow_dispatch' && inputs.tag || needs.release-please.outputs.tag_name }}
+      GH_TOKEN: ${{ github.token }}
+    outputs:
+      release_tag: ${{ steps.release.outputs.release_tag }}
+      release_version: ${{ steps.release.outputs.release_version }}
+      release_sha: ${{ steps.release.outputs.release_sha }}
+    steps:
+      - name: Checkout the release tag
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ env.RELEASE_TAG }}
+          fetch-depth: 0
+
+      - name: Resolve and validate the release
+        id: release
+        run: |
+          set -euo pipefail
+          if [ -z "$RELEASE_TAG" ] || [[ ! "$RELEASE_TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "::error::Release tag '$RELEASE_TAG' must look like v0.3.4."
+            exit 1
+          fi
+          gh release view "$RELEASE_TAG" --repo "${{ github.repository }}" >/dev/null
+
+          RELEASE_SHA=$(git rev-parse HEAD)
+          TAG_SHA=$(git rev-list -n 1 "$RELEASE_TAG")
+          if [ "$RELEASE_SHA" != "$TAG_SHA" ]; then
+            echo "::error::$RELEASE_TAG points to $TAG_SHA, but checkout is $RELEASE_SHA."
+            exit 1
+          fi
+
+          VERSION=${RELEASE_TAG#v}
+          python scripts/check_release_versions.py --expected "$VERSION"
+
+          PARENT_SHA=$(git rev-parse "$RELEASE_SHA^")
+          UNEXPECTED=$(git diff --name-only "$PARENT_SHA" "$RELEASE_SHA" | grep -Ev \
+            '^(\.release-please-manifest\.json|CHANGELOG\.md|pyproject\.toml|uv\.lock|src/tavus_mcp/__init__\.py|workers/tavus-mcp/package\.json|workers/tavus-mcp/package-lock\.json|workers/tavus-mcp/src/version\.ts|packages/tavus/pyproject\.toml|packages/tavus-mcp/pyproject\.toml)$' || true)
+          if [ -n "$UNEXPECTED" ]; then
+            echo "::error::The release commit contains files that were not staged:"
+            echo "$UNEXPECTED"
+            exit 1
+          fi
+
+          DEPLOYMENTS=$(gh api "/repos/${{ github.repository }}/deployments?environment=stg&sha=$PARENT_SHA&per_page=20")
+          STAGED=false
+          while read -r DEPLOYMENT_ID; do
+            if gh api "/repos/${{ github.repository }}/deployments/$DEPLOYMENT_ID/statuses?per_page=20" \
+              --jq 'any(.[]; .state == "success")' | grep -qx true; then
+              STAGED=true
+              break
+            fi
+          done < <(jq -r '.[].id' <<<"$DEPLOYMENTS")
+          if [ "$STAGED" != true ]; then
+            echo "::error::Release parent $PARENT_SHA has no successful stg deployment."
+            exit 1
+          fi
+
+          echo "release_tag=$RELEASE_TAG" >>"$GITHUB_OUTPUT"
+          echo "release_version=$VERSION" >>"$GITHUB_OUTPUT"
+          echo "release_sha=$RELEASE_SHA" >>"$GITHUB_OUTPUT"
+          echo "Release $RELEASE_TAG promotes staged parent $PARENT_SHA."
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install uv
+        run: pip install uv
+
+      - name: Install Python dependencies
+        run: uv sync --extra dev
+
+      - name: Ruff
+        run: uv run ruff check .
+
+      - name: Pytest
+        env:
+          COLUMNS: '200'
+        run: uv run pytest -q
+
+      - name: Build Python distributions
+        run: |
+          uv build
+          uv build packages/tavus --out-dir dist
+          uv build packages/tavus-mcp --out-dir dist
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+          cache-dependency-path: workers/tavus-mcp/package-lock.json
+
+      - name: Install Worker dependencies
+        working-directory: workers/tavus-mcp
+        run: npm ci
+
+      - name: Type-check Worker
+        working-directory: workers/tavus-mcp
+        run: npm run build
+
+      - name: Test Worker
+        working-directory: workers/tavus-mcp
+        run: npm test
+
+      - name: Upload Python distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: tavus-cli-${{ steps.release.outputs.release_version }}
+          path: dist/*
+          if-no-files-found: error
+          retention-days: 7
+
+  update-pending-board:
+    name: Show the production approval in Slack
+    needs: preflight
+    runs-on: ubuntu-latest
+    timeout-minutes: 7
+    steps:
+      - name: Wait for the production job to request approval
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          for ATTEMPT in $(seq 1 20); do
+            DEPLOYMENTS=$(gh api "/repos/${{ github.repository }}/deployments?environment=prod&sha=${{ needs.preflight.outputs.release_sha }}&per_page=10" || true)
+            while read -r DEPLOYMENT_ID; do
+              STATE=$(gh api "/repos/${{ github.repository }}/deployments/$DEPLOYMENT_ID/statuses?per_page=1" --jq '.[0].state // ""' || true)
+              if [ "$STATE" = "waiting" ]; then
+                echo "Production is waiting for approval."
+                exit 0
+              fi
+              if [ -n "$STATE" ]; then
+                echo "Production already moved to '$STATE'; refreshing the tabs now."
+                exit 0
+              fi
+            done < <(jq -r '.[].id' <<<"${DEPLOYMENTS:-[]}" 2>/dev/null || true)
+            sleep 15
+          done
+          echo "::warning::Production approval did not appear before the Slack refresh."
+
+      - name: Refresh Slack deployment tabs
+        continue-on-error: true
+        uses: Tavus-Engineering/pr-changelog-action/status@main
+        with:
+          slack-bot-token: ${{ secrets.CVI_BOT_SLACK_TOKEN }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+  production:
+    name: Deploy Worker and publish CLI
+    needs: preflight
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    environment: prod
+    env:
+      CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+      CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+    steps:
+      - name: Checkout the exact release tag
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.preflight.outputs.release_tag }}
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+          cache-dependency-path: workers/tavus-mcp/package-lock.json
+
+      - name: Install Worker dependencies
+        working-directory: workers/tavus-mcp
+        run: npm ci
+
+      - name: Deploy the hosted Worker
+        working-directory: workers/tavus-mcp
+        run: npx wrangler deploy --env prod
+
+      - name: Smoke-test production OAuth and MCP routes
+        run: |
+          curl --fail --silent --show-error \
+            https://mcp.tavus.io/.well-known/oauth-protected-resource/mcp >/dev/null
+          curl --fail --silent --show-error \
+            https://mcp.tavus.io/.well-known/oauth-authorization-server >/dev/null
+          STATUS=$(curl --silent --output /tmp/tavus-mcp-response \
+            --write-out '%{http_code}' https://mcp.tavus.io/mcp)
+          if [ "$STATUS" != "401" ]; then
+            echo "::error::https://mcp.tavus.io/mcp returned $STATUS; expected 401 without credentials."
+            cat /tmp/tavus-mcp-response
+            exit 1
+          fi
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install uv
+        run: pip install uv
+
+      - name: Download Python distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: tavus-cli-${{ needs.preflight.outputs.release_version }}
+          path: dist
+
+      - name: Publish Tavus CLI and its alias packages to PyPI
+        run: uv publish --trusted-publishing always --check-url https://pypi.org/simple/ dist/*
+
+  notify-cvi-automations:
+    name: 'Notify #cvi-automations (prod deploy)'
+    needs: [preflight, production]
+    if: ${{ always() && !cancelled() && needs.preflight.result == 'success' }}
+    runs-on: ubuntu-latest
+    # A Slack or mention-resolution failure must not change the deploy result.
+    continue-on-error: true
+    timeout-minutes: 5
+    steps:
+      - name: Resolve release author mentions
+        id: mentions
+        continue-on-error: true
+        timeout-minutes: 2
+        uses: Tavus-Engineering/pr-changelog-action/release-mentions@main
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          deploy-tag: ${{ needs.preflight.outputs.release_tag }}
+          environment: prod
+
+      - name: 'Post outcome to #cvi-automations'
+        env:
+          SLACK_BOT_TOKEN: ${{ secrets.CVI_BOT_SLACK_TOKEN }}
+          MENTIONS: ${{ steps.mentions.outputs.mentions }}
+          DEPLOY_RESULT: ${{ needs.production.result }}
+          RELEASE_TAG: ${{ needs.preflight.outputs.release_tag }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        run: |
+          set -euo pipefail
+          AUTHOR_TAGS="${MENTIONS:+${MENTIONS} }"
+          CVI_TEAM="<!subteam^S08HUM36HMZ>"
+          if [ "$DEPLOY_RESULT" = "success" ]; then
+            TEXT=":white_check_mark: ${AUTHOR_TAGS}Tavus MCP <${RUN_URL}|${RELEASE_TAG}> is live in production."
+          else
+            TEXT=":x: ${CVI_TEAM} Tavus MCP production deploy failed — <${RUN_URL}|run>."
+          fi
+
+          RESPONSE=$(curl --fail-with-body --silent --show-error \
+            --connect-timeout 5 --max-time 30 \
+            -X POST https://slack.com/api/chat.postMessage \
+            -H "Authorization: Bearer ${SLACK_BOT_TOKEN}" \
+            -H "Content-Type: application/json; charset=utf-8" \
+            --data "$(jq -n --arg channel "C0B9S5Y556V" --arg text "$TEXT" \
+              '{channel:$channel, text:$text, unfurl_links:false}')")
+          echo "$RESPONSE" | jq .
+          echo "$RESPONSE" | jq -e '.ok == true' >/dev/null
+
+  update-final-board:
+    name: Refresh Slack after production
+    needs: [preflight, update-pending-board, production]
+    if: always() && needs.preflight.result == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Refresh Slack deployment tabs
+        continue-on-error: true
+        uses: Tavus-Engineering/pr-changelog-action/status@main
+        with:
+          slack-bot-token: ${{ secrets.CVI_BOT_SLACK_TOKEN }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}

tavus_cli-0.4.0/.github/workflows/tail-cloudflare-worker.yml

@@ -0,0 +1,52 @@
+name: Tail Tavus MCP Worker
+
+on:
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: Cloudflare Worker environment to tail
+        required: true
+        default: prod
+        type: choice
+        options:
+          - test
+          - stg
+          - prod
+      seconds:
+        description: How long to stream logs before exiting
+        required: true
+        default: "120"
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  tail:
+    runs-on: ubuntu-latest
+    environment: ${{ inputs.environment }}
+    env:
+      CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+      CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+    defaults:
+      run:
+        working-directory: workers/tavus-mcp
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+          cache-dependency-path: workers/tavus-mcp/package-lock.json
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Tail Worker logs
+        # timeout exits 124 when the window closes; that is the expected success path.
+        run: |
+          timeout "${{ inputs.seconds }}" npx wrangler tail --env "${{ inputs.environment }}" --format json || [ $? -eq 124 ]

tavus_cli-0.4.0/.github/workflows/validate-staging-deployment.yml

@@ -0,0 +1,87 @@
+name: Validate staging deployment
+
+on:
+  pull_request:
+    branches: [main]
+    paths: [CHANGELOG.md]
+  workflow_dispatch:
+    inputs:
+      main_sha:
+        description: Exact main commit that the release pull request promotes
+        required: true
+        type: string
+
+permissions:
+  actions: read
+  contents: read
+
+concurrency:
+  group: validate-staging-${{ github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  validate-staging:
+    name: Validate the current main commit in staging
+    if: >-
+      github.event_name == 'workflow_dispatch' ||
+      startsWith(github.head_ref, 'release-please')
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Wait for the exact staging deployment
+        env:
+          GH_TOKEN: ${{ github.token }}
+          EXPECTED_MAIN_SHA: ${{ github.event_name == 'workflow_dispatch' && inputs.main_sha || '' }}
+        run: |
+          while :; do
+            MAIN_TIP=$EXPECTED_MAIN_SHA
+            if [ -z "$MAIN_TIP" ]; then
+              MAIN_TIP=$(gh api "/repos/${{ github.repository }}/commits/main" \
+                --jq '.sha' || true)
+            fi
+            if [ -z "$MAIN_TIP" ]; then
+              echo "Could not resolve main; retrying."
+              sleep 30
+              continue
+            fi
+
+            RUN=$(gh api \
+              "/repos/${{ github.repository }}/actions/workflows/deploy-cloudflare-worker.yml/runs?branch=main&head_sha=$MAIN_TIP&event=push&per_page=1" \
+              --jq '.workflow_runs[0]' || true)
+            if [ -z "$RUN" ] || [ "$RUN" = "null" ]; then
+              echo "No staging run for $MAIN_TIP yet; waiting."
+              sleep 30
+              continue
+            fi
+
+            STATUS=$(jq -r '.status' <<<"$RUN")
+            CONCLUSION=$(jq -r '.conclusion' <<<"$RUN")
+            RUN_ID=$(jq -r '.id' <<<"$RUN")
+            URL=$(jq -r '.html_url' <<<"$RUN")
+            if [ "$STATUS" != "completed" ]; then
+              echo "Staging run for $MAIN_TIP is $STATUS; waiting. $URL"
+              sleep 30
+              continue
+            fi
+
+            if [ "$CONCLUSION" != "success" ]; then
+              echo "::error::Staging run for $MAIN_TIP concluded '$CONCLUSION'."
+              echo "View the run: $URL"
+              exit 1
+            fi
+
+            DEPLOY_JOB=$(gh api "/repos/${{ github.repository }}/actions/runs/$RUN_ID/jobs?per_page=100" \
+              --jq 'first(.jobs[] | select(.name == "Deploy Worker to stg")) // empty')
+            if [ -z "$DEPLOY_JOB" ]; then
+              echo "::error::Run $RUN_ID has no 'Deploy Worker to stg' job."
+              exit 1
+            fi
+            if [ "$(jq -r '.conclusion' <<<"$DEPLOY_JOB")" != "success" ]; then
+              echo "::error::The staging deploy job did not succeed."
+              echo "View the run: $URL"
+              exit 1
+            fi
+
+            echo "Staging deployed current main commit $MAIN_TIP successfully."
+            break
+          done

tavus_cli-0.4.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.4.0"
+}

tavus_cli-0.4.0/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+## [0.4.0](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.3.4...v0.4.0) (2026-08-26)
+
+
+### Features
+
+* notify cvi-automations after MCP deploys ([#41](https://github.com/Tavus-Engineering/tavus-mcp/issues/41)) ([169d092](https://github.com/Tavus-Engineering/tavus-mcp/commit/169d092b6b9241256316e3d8f6a0a633319b70ef))
+* publish tavus and tavus-mcp alias packages ([2c781a0](https://github.com/Tavus-Engineering/tavus-mcp/commit/2c781a059b1ef06acd2d4293239e41d568c4f0ce))
+
+## [0.3.4](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.3.3...v0.3.4) (2026-08-25)
+
+
+### Bug Fixes
+
+* automate Tavus MCP releases ([#34](https://github.com/Tavus-Engineering/tavus-mcp/issues/34)) ([a76cfc5](https://github.com/Tavus-Engineering/tavus-mcp/commit/a76cfc5938e4fabc730e0109649e0dea63f966b6))
+* keep the Python package version in releases ([#38](https://github.com/Tavus-Engineering/tavus-mcp/issues/38)) ([85d8809](https://github.com/Tavus-Engineering/tavus-mcp/commit/85d8809fcc707b71c9daedcb4ed5f2faac4f5334))
+* regenerate the release lockfile before CI ([#39](https://github.com/Tavus-Engineering/tavus-mcp/issues/39)) ([f0afd76](https://github.com/Tavus-Engineering/tavus-mcp/commit/f0afd760926132c3d5cb3c29d4afd8d261ba3306))
+
+
+### Documentation
+
+* rewrite the README around the current CLI and MCP surfaces ([252a808](https://github.com/Tavus-Engineering/tavus-mcp/commit/252a808b22406239dfe8c552b9c7338ca29a539e))
+
+
+### Continuous Integration
+
+* run release checks without an app secret ([#35](https://github.com/Tavus-Engineering/tavus-mcp/issues/35)) ([9bee88a](https://github.com/Tavus-Engineering/tavus-mcp/commit/9bee88ad3b62c448a53e27ea7381aeca42d4dd2b))
+* target the repository for release check dispatch ([#37](https://github.com/Tavus-Engineering/tavus-mcp/issues/37)) ([1cb9d8e](https://github.com/Tavus-Engineering/tavus-mcp/commit/1cb9d8e8cde12e3bd8a1b6b5fcd7768470264e1c))
+
+## Changelog
+
+Release notes for Tavus CLI and the hosted Tavus MCP Worker appear here.