COMMAND_ID="your-command-id"

while true; do
  RESULT=$(curl -s https://renderio.dev/api/v1/commands/$COMMAND_ID \
    -H "X-API-KEY: $RENDERIO_API_KEY")
  STATUS=$(echo $RESULT | jq -r '.status')
  echo "Status: $STATUS"
  if [ "$STATUS" = "SUCCESS" ] || [ "$STATUS" = "FAILED" ]; then break; fi
  sleep 2
done

echo $RESULT | jq .

import time
import requests

def wait_for_command(command_id, api_key):
    base_url = "https://api.renderio.dev"

    while True:
        response = requests.get(
            f"{base_url}/api/v1/commands/{command_id}",
            headers={"X-API-KEY": api_key},
        )
        result = response.json()

        if result["status"] == "SUCCESS":
            return result

        if result["status"] == "FAILED":
            raise Exception(f"Command failed: {result.get('error_message')}")

        time.sleep(2)

interface CommandResult {
  command_id: string;
  status: "QUEUED" | "PROCESSING" | "SUCCESS" | "FAILED";
  error_message?: string;
  output_files: Record<string, { file_id: string; storage_url: string }>;
}

async function waitForCommand(commandId: string, apiKey: string): Promise<CommandResult> {
  const BASE_URL = "https://api.renderio.dev";

  while (true) {
    const response = await fetch(
      `${BASE_URL}/api/v1/commands/${commandId}`,
      { headers: { "X-API-KEY": apiKey } },
    );
    const result = (await response.json()) as CommandResult;

    if (result.status === "SUCCESS") {
      return result;
    }

    if (result.status === "FAILED") {
      throw new Error(`Command failed: ${result.error_message}`);
    }

    await new Promise((resolve) => setTimeout(resolve, 2000));
  }
}

async function waitForCommand(commandId, apiKey) {
  const BASE_URL = "https://api.renderio.dev";

  while (true) {
    const response = await fetch(
      `${BASE_URL}/api/v1/commands/${commandId}`,
      { headers: { "X-API-KEY": apiKey } },
    );
    const result = await response.json();

    if (result.status === "SUCCESS") {
      return result;
    }

    if (result.status === "FAILED") {
      throw new Error(`Command failed: ${result.error_message}`);
    }

    await new Promise((resolve) => setTimeout(resolve, 2000));
  }
}

<?php
function waitForCommand(string $commandId, string $apiKey): array {
    $baseUrl = "https://api.renderio.dev";

    while (true) {
        $ch = curl_init("$baseUrl/api/v1/commands/$commandId");
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ["X-API-KEY: $apiKey"]);
        $result = json_decode(curl_exec($ch), true);
        curl_close($ch);

        if ($result["status"] === "SUCCESS") {
            return $result;
        }

        if ($result["status"] === "FAILED") {
            throw new Exception("Command failed: " . $result["error_message"]);
        }

        sleep(2);
    }
}

# Verify a webhook signature manually
BODY='{"data":{"command_id":"..."},"timestamp":1700000000000}'
SECRET="your_webhook_secret_here"
EXPECTED=$(echo -n "$BODY" | openssl dgst -sha256 -hmac "$SECRET" | awk '{print $2}')
echo "Expected signature: $EXPECTED"

import hmac
import hashlib
from flask import Flask, request

app = Flask(__name__)

def verify_signature(body: bytes, signature: str, secret: str) -> bool:
    expected = hmac.new(
        secret.encode(), body, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

@app.route("/webhooks/renderio", methods=["POST"])
def webhook_handler():
    signature = request.headers.get("X-Webhook-Signature", "")
    raw_body = request.get_data()

    if not verify_signature(raw_body, signature, os.environ["WEBHOOK_SECRET"]):
        return "Invalid signature", 401

    payload = request.get_json()
    print(f"Command completed: {payload['data']['command_id']}")
    print(f"Status: {payload['data']['status']}")

    return "OK", 200

import { createHmac } from "node:crypto";
import express, { type Request, type Response } from "express";

const app = express();

function verifyWebhookSignature(body: string, signature: string, secret: string): boolean {
  const expected = createHmac("sha256", secret)
    .update(body)
    .digest("hex");
  return expected === signature;
}

app.post("/webhooks/renderio", (req: Request, res: Response) => {
  const signature = req.headers["x-webhook-signature"] as string;
  const rawBody = req.body as string;

  if (!verifyWebhookSignature(rawBody, signature, process.env.WEBHOOK_SECRET!)) {
    return res.status(401).send("Invalid signature");
  }

  const payload = JSON.parse(rawBody);
  console.log("Command completed:", payload.data.command_id);
  console.log("Status:", payload.data.status);

  res.status(200).send("OK");
});

import { createHmac } from "node:crypto";

function verifyWebhookSignature(body, signature, secret) {
  const expected = createHmac("sha256", secret)
    .update(body)
    .digest("hex");
  return expected === signature;
}

// In your webhook handler (e.g. Express)
app.post("/webhooks/renderio", (req, res) => {
  const signature = req.headers["x-webhook-signature"];
  const rawBody = req.body; // raw string, not parsed JSON

  if (!verifyWebhookSignature(rawBody, signature, process.env.WEBHOOK_SECRET)) {
    return res.status(401).send("Invalid signature");
  }

  const payload = JSON.parse(rawBody);
  console.log("Command completed:", payload.data.command_id);
  console.log("Status:", payload.data.status);

  res.status(200).send("OK");
});

<?php
function verifyWebhookSignature(string $body, string $signature, string $secret): bool {
    $expected = hash_hmac("sha256", $body, $secret);
    return hash_equals($expected, $signature);
}

// In your webhook handler
$rawBody = file_get_contents("php://input");
$signature = $_SERVER["HTTP_X_WEBHOOK_SIGNATURE"] ?? "";
$secret = getenv("WEBHOOK_SECRET");

if (!verifyWebhookSignature($rawBody, $signature, $secret)) {
    http_response_code(401);
    echo "Invalid signature";
    exit;
}

$payload = json_decode($rawBody, true);
echo "Command completed: " . $payload["data"]["command_id"] . "\n";
echo "Status: " . $payload["data"]["status"] . "\n";

http_response_code(200);
echo "OK";