gRPC API

cd gen
protoc --go_out=. --go_opt=paths=source_relative \
       --go-grpc_out=. --go-grpc_opt=paths=source_relative \
       api.proto

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "strings"

    boxdv1 "yourmodule/gen"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    "google.golang.org/grpc/metadata"
)

func exchange(apiKey string) string {
    body := strings.NewReader(`{"api_key":"` + apiKey + `"}`)
    resp, err := http.Post("https://app.boxd.sh/api/v1/auth/token",
        "application/json", body)
    if err != nil { log.Fatal(err) }
    defer resp.Body.Close()
    var out struct{ Token string }
    json.NewDecoder(resp.Body).Decode(&out)
    return out.Token
}

func main() {
    jwt := exchange("bxd_...")

    conn, err := grpc.NewClient("boxd.sh:9443",
        grpc.WithTransportCredentials(credentials.NewTLS(nil)))
    if err != nil { log.Fatal(err) }
    defer conn.Close()

    client := boxdv1.NewBoxdApiClient(conn)
    ctx := metadata.AppendToOutgoingContext(context.Background(),
        "authorization", "Bearer "+jwt)

    me, err := client.Whoami(ctx, &boxdv1.WhoamiRequest{})
    if err != nil { log.Fatal(err) }
    fmt.Println("user:", me.UserId)

    vm, err := client.CreateVm(ctx, &boxdv1.CreateVmRequest{
        Name: "hello-grpc",
    })
    if err != nil { log.Fatal(err) }
    fmt.Printf("created %s at %s (%dms)\n",
        vm.Name, vm.Url, vm.BootTimeMs)
}

npm install @grpc/grpc-js @grpc/proto-loader

import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';

async function exchange(apiKey: string): Promise<string> {
  const r = await fetch('https://app.boxd.sh/api/v1/auth/token', {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ api_key: apiKey }),
  });
  const { token } = await r.json();
  return token;
}

async function main() {
  const jwt = await exchange('bxd_...');

  const def = protoLoader.loadSync('./api.proto', {
    keepCase: true, longs: String, enums: String, defaults: true,
  });
  const proto = grpc.loadPackageDefinition(def) as any;

  const meta = new grpc.Metadata();
  meta.set('authorization', `Bearer ${jwt}`);

  const client = new proto.boxd.api.v1.BoxdApi(
    'boxd.sh:9443',
    grpc.credentials.createSsl(),
  );

  client.Whoami({}, meta, (err: any, me: any) => {
    if (err) throw err;
    console.log('user:', me.user_id);

    client.CreateVm({ name: 'hello-grpc' }, meta, (err: any, vm: any) => {
      if (err) throw err;
      console.log(`created ${vm.name} at ${vm.url} (${vm.boot_time_ms}ms)`);
    });
  });
}

main();

pip install grpcio grpcio-tools requests
python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. api.proto

import grpc
import requests
import api_pb2 as pb
import api_pb2_grpc as rpc

def exchange(api_key: str) -> str:
    r = requests.post(
        "https://app.boxd.sh/api/v1/auth/token",
        json={"api_key": api_key},
    )
    r.raise_for_status()
    return r.json()["token"]

def main():
    jwt = exchange("bxd_...")
    meta = (("authorization", f"Bearer {jwt}"),)

    with grpc.secure_channel("boxd.sh:9443", grpc.ssl_channel_credentials()) as ch:
        client = rpc.BoxdApiStub(ch)

        me = client.Whoami(pb.WhoamiRequest(), metadata=meta)
        print("user:", me.user_id)

        vm = client.CreateVm(pb.CreateVmRequest(name="hello-grpc"), metadata=meta)
        print(f"created {vm.name} at {vm.url} ({vm.boot_time_ms}ms)")

if __name__ == "__main__":
    main()