curl -X POST https://api.secrooq.com/sandboxes \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "autonomous-agent-01",
    "type": "ai_agent",
    "instance_type": "standard-1",
    "image": "ubuntu:22.04"
  }'

Authorization: Bearer secrooq-super-secret-jwt-key...

class SecrooqCompute {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = "https://api.secrooq.com";
  }

  async request(path, options = {}) {
    const response = await fetch(`${this.baseUrl}${path}`, {
      ...options,
      headers: {
        "Authorization": `Bearer ${this.apiKey}`,
        "Content-Type": "application/json",
        ...options.headers
      }
    });
    return response.json();
  }

  // Provision microVM
  async createSandbox(name, options = {}) {
    return this.request("/sandboxes", {
      method: "POST",
      body: JSON.stringify({ name, ...options })
    });
  }

  // Execute terminal command
  async executeCommand(sandboxId, command) {
    return this.request(`/sandboxes/${sandboxId}/exec`, {
      method: "POST",
      body: JSON.stringify({ command })
    });
  }

  // Destroy sandbox instance
  async destroySandbox(sandboxId) {
    return this.request(`/sandboxes/${sandboxId}`, {
      method: "DELETE"
    });
  }
}

// Client usage
(async () => {
  const secrooq = new SecrooqCompute("YOUR_JWT_TOKEN");
  
  console.log("🚀 Provisioning microVM...");
  const vm = await secrooq.createSandbox("js-sdk-example");
  console.log("Created!", vm);

  if (vm.id) {
    console.log("🏃 Executing node scripts...");
    const res = await secrooq.executeCommand(vm.id, "node -v");
    console.log("Output:", res.output);

    console.log("🧹 Destroying sandbox...");
    await secrooq.destroySandbox(vm.id);
    console.log("VM cleaned up.");
  }
})();

import urllib.request
import json

class SecrooqCompute:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.secrooq.com"

    def _request(self, path: str, method: str = "GET", data: dict = None):
        url = f"{self.base_url}{path}"
        req = urllib.request.Request(url, method=method)
        req.add_header("Authorization", f"Bearer {self.api_key}")
        req.add_header("Content-Type", "application/json")
        
        payload = json.dumps(data).encode("utf-8") if data else None
        try:
            with urllib.request.urlopen(req, data=payload) as response:
                return json.loads(response.read().decode("utf-8"))
        except urllib.error.HTTPError as e:
            return json.loads(e.read().decode("utf-8"))

    def create_sandbox(self, name: str, instance_type: str = "standard-1"):
        return self._request("/sandboxes", "POST", {"name": name, "instance_type": instance_type})

    def execute_command(self, sandbox_id: str, command: str):
        return self._request(f"/sandboxes/{sandbox_id}/exec", "POST", {"command": command})

    def destroy_sandbox(self, sandbox_id: str):
        return self._request(f"/sandboxes/{sandbox_id}", "DELETE")

# Usage Example
if __name__ == "__main__":
    secrooq = SecrooqCompute("YOUR_JWT_TOKEN")
    
    print("🚀 Spawning agent sandbox in Python...")
    vm = secrooq.create_sandbox("python-agent-01")
    print("Sandbox details:", vm)
    
    if "id" in vm:
        sandbox_id = vm["id"]
        print(f"🏃 Running telemetry checks on sandbox {sandbox_id}...")
        res = secrooq.execute_command(sandbox_id, "python3 --version")
        print("Output:", res.get("output", ""))
        
        print("🧹 Cleaning environment...")
        secrooq.destroy_sandbox(sandbox_id)
        print("Sandbox destroyed.")

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY agent.py .
CMD ["python", "agent.py"]

docker build -t yourusername/your-agent-name:v1 .

docker login
docker push yourusername/your-agent-name:v1

earnings = price_per_hour × (seconds_used / 3600) × 0.80

docker run -it --rm yourusername/your-agent-name:v1