Developer Guide

// Recommended: PAT from your org admin or Mobile Approver (X-PAT header)
client.setPat("<your-pat>");

// After obtaining a PAT from your org admin or Mobile Approver
client.SetPat("<your-pat>");

// After obtaining a PAT from your org admin or Mobile Approver
client.SetPat("<your-pat>")

// After obtaining a PAT from your org admin or Mobile Approver
client.set_pat(Some("<your-pat>".to_string()));

import { AirlockGatewayClient } from "@airlockapp/gateway-sdk";

const client = new AirlockGatewayClient({
  baseUrl: "https://<your-gateway-host>",
  token: "<user-jwt>",
});

using Airlock.Gateway.Sdk;

var client = new AirlockGatewayClient("https://<your-gateway-host>", bearerToken: "<user-jwt>");

client := airlock.NewClient("https://<your-gateway-host>", "<user-jwt>")

let client = AirlockGatewayClient::new(
    "https://<your-gateway-host>",
    Some("<user-jwt>"),
)?;

// After user login (Device Auth Grant or Auth Code + PKCE)
client.setBearerToken(accessToken);

// After user login (Device Auth Grant or Auth Code + PKCE)
client.SetBearerToken(accessToken);

// After user login (Device Auth Grant or Auth Code + PKCE)
client.SetBearerToken(accessToken)

// After user login (Device Auth Grant or Auth Code + PKCE)
client.set_bearer_token(Some(access_token));

import { AirlockGatewayClient } from "@airlockapp/gateway-sdk";

const client = new AirlockGatewayClient({
  baseUrl: "https://<your-gateway-host>",
  clientId: "<your-client-id>",
  clientSecret: "<your-client-secret>",
});

var httpClient = new HttpClient { BaseAddress = new Uri("https://<your-gateway-host>") };
httpClient.DefaultRequestHeaders.Add("X-Client-Id", "<your-client-id>");
httpClient.DefaultRequestHeaders.Add("X-Client-Secret", "<your-client-secret>");

var client = new AirlockGatewayClient(httpClient);

client := airlock.NewClientWithCredentials(
    "https://<your-gateway-host>",
    "<your-client-id>",
    "<your-client-secret>",
)

let client = AirlockGatewayClient::with_credentials(
    "https://<your-gateway-host>",
    "<your-client-id>",
    "<your-client-secret>",
)?;

// Set the PAT on the client (recommended for CLIs / scripts)
client.setPat("<your-pat>");

// Set the PAT on the client (recommended for CLIs / scripts)
client.SetPat("<your-pat>");

// Set the PAT on the client (recommended for CLIs / scripts)
client.SetPat("<your-pat>")

// Set the PAT on the client (recommended for CLIs / scripts)
client.set_pat(Some("<your-pat>".to_string()));

// After obtaining the access token
client.setBearerToken(accessToken);

// After obtaining the access token
client.SetBearerToken(accessToken);

// After obtaining the access token
client.SetBearerToken(accessToken)

// After obtaining the access token
client.set_bearer_token(Some(access_token));

const response = await client.initiatePairing({
  enforcerId: "my-enforcer",
  enforcerLabel: "My Custom Enforcer",
  workspaceName: "default",
});

console.log(`Pairing code: ${response.pairingCode}`);

var pairing = await client.InitiatePairingAsync(new PairingInitiateRequest
{
    EnforcerId = "my-enforcer",
    EnforcerLabel = "My Custom Enforcer",
    WorkspaceName = "default",
});

Console.WriteLine($"Pairing code: {pairing.PairingCode}");

resp, err := client.InitiatePairing(airlock.PairingInitiateRequest{
    EnforcerID:     "my-enforcer",
    EnforcerLabel:  "My Custom Enforcer",
    WorkspaceName:  "default",
})
fmt.Printf("Pairing code: %s\n", resp.PairingCode)

let resp = client.initiate_pairing(PairingInitiateRequest {
    enforcer_id: "my-enforcer".into(),
    enforcer_label: Some("My Custom Enforcer".into()),
    workspace_name: "default".into(),
    ..Default::default()
}).await?;

println!("Pairing code: {}", resp.pairing_code);

const status = await client.getPairingStatus(response.nonce);
if (status.state === "Completed") {
  const routingToken = status.routingToken;
  // Save this token — you'll need it for all subsequent requests
}

var status = await client.GetPairingStatusAsync(pairing.Nonce);
if (status.State == "Completed")
{
    var routingToken = status.RoutingToken;
}

status, err := client.GetPairingStatus(resp.Nonce)
if status.State == "Completed" {
    routingToken := status.RoutingToken
}

let status = client.get_pairing_status(&resp.nonce).await?;
if status.state == "Completed" {
    let routing_token = status.routing_token;
}

const claim = await client.claimPairing({
  code: "ABCD-1234",
  enforcerId: "my-enforcer",
  enforcerLabel: "My Custom Enforcer",
  workspaceName: "default",
});
const routingToken = claim.routingToken;

var claim = await client.ClaimPairingAsync(new PairingClaimRequest
{
    Code = "ABCD-1234",
    EnforcerId = "my-enforcer",
    EnforcerLabel = "My Custom Enforcer",
    WorkspaceName = "default",
});
var routingToken = claim.RoutingToken;

claim, err := client.ClaimPairing(airlock.PairingClaimRequest{
    Code:          "ABCD-1234",
    EnforcerID:    "my-enforcer",
    EnforcerLabel: "My Custom Enforcer",
    WorkspaceName: "default",
})
routingToken := claim.RoutingToken

let claim = client.claim_pairing(PairingClaimRequest {
    code: "ABCD-1234".into(),
    enforcer_id: "my-enforcer".into(),
    enforcer_label: Some("My Custom Enforcer".into()),
    workspace_name: "default".into(),
    ..Default::default()
}).await?;
let routing_token = claim.routing_token;

await client.sendHeartbeat({
  enforcerId: "my-enforcer",
  enforcerLabel: "My Custom Enforcer",
  workspaceName: "default",
});

await client.SendHeartbeatAsync(new HeartbeatRequest
{
    EnforcerId = "my-enforcer",
    EnforcerLabel = "My Custom Enforcer",
    WorkspaceName = "default",
});

err := client.SendHeartbeat(airlock.HeartbeatRequest{
    EnforcerID:    "my-enforcer",
    EnforcerLabel: "My Custom Enforcer",
    WorkspaceName: "default",
})

client.send_heartbeat(HeartbeatRequest {
    enforcer_id: "my-enforcer".into(),
    enforcer_label: Some("My Custom Enforcer".into()),
    workspace_name: "default".into(),
    ..Default::default()
}).await?;

const requestId = await client.submitArtifact({
  enforcerId: "my-enforcer",
  artifactType: "command.review",
  artifactHash: "sha256-of-content",
  ciphertext: {
    alg: "aes-256-gcm",
    data: "<base64-encrypted-payload>",
    nonce: "<base64-nonce>",
    tag: "<base64-auth-tag>",
  },
  metadata: { routingToken, workspaceName: "default" },
});

var requestId = await client.SubmitArtifactAsync(new ArtifactSubmitRequest
{
    EnforcerId = "my-enforcer",
    ArtifactType = "command.review",
    ArtifactHash = "sha256-of-content",
    Ciphertext = new EncryptedPayload
    {
        Alg = "aes-256-gcm",
        Data = "<base64-encrypted-payload>",
        Nonce = "base64-nonce",
        Tag = "base64-auth-tag",
    },
    Metadata = new Dictionary<string, string>
    {
        ["routingToken"] = routingToken,
        ["workspaceName"] = "default",
    },
});

requestID, err := client.SubmitArtifact(airlock.ArtifactSubmitRequest{
    EnforcerID:   "my-enforcer",
    ArtifactType: "command.review",
    ArtifactHash: "sha256-of-content",
    Ciphertext: airlock.EncryptedPayload{
        Alg:   "aes-256-gcm",
        Data:  "<base64-encrypted-payload>",
        Nonce: "<base64-nonce>",
        Tag:   "<base64-auth-tag>",
    },
    Metadata: map[string]string{
        "routingToken":  routingToken,
        "workspaceName": "default",
    },
})

let request_id = client.submit_artifact(ArtifactSubmitRequest {
    enforcer_id: "my-enforcer".into(),
    artifact_type: Some("command.review".into()),
    artifact_hash: "sha256-of-content".into(),
    ciphertext: EncryptedPayload {
        alg: "aes-256-gcm".into(),
        data: "<base64-encrypted-payload>".into(),
        nonce: Some("<base64-nonce>".into()),
        tag: Some("<base64-auth-tag>".into()),
        aad: None,
    },
    metadata: Some(HashMap::from([
        ("routingToken".into(), routing_token),
        ("workspaceName".into(), "default".into()),
    ])),
    ..Default::default()
}).await?;

const decision = await client.waitForDecision(requestId, 25);

if (decision?.body?.decision === "approve") {
  // Execute the agent's action
} else {
  const reason = decision?.body?.reason;
}

var decision = await client.WaitForDecisionAsync(requestId, timeoutSeconds: 25);
if (decision?.Body?.IsApproved == true)
{
    // Execute the agent's action
}
else
{
    var reason = decision?.Body?.Reason;
}

decision, err := client.WaitForDecision(requestID, 25)
if decision != nil && decision.Body.IsApproved() {
    // Execute the agent's action
} else {
    reason := decision.Body.Reason
}

if let Some(decision) = client.wait_for_decision(&request_id, 25).await? {
    if let Some(body) = &decision.body {
        if body.is_approved() {
            // Execute the agent's action
        } else {
            let reason = &body.reason;
        }
    }
}

// After receiving a decision: confirm delivery to the gateway (fire-and-forget)
await client.submitAck(msgId, requestId);

// After receiving a decision: confirm delivery to the gateway (fire-and-forget)
await client.SubmitAckAsync(msgId, requestId);

// After receiving a decision: confirm delivery to the gateway (fire-and-forget)
err := client.SubmitAck(msgID, requestID)

// After receiving a decision: confirm delivery to the gateway (fire-and-forget)
client.submit_ack(&msg_id, &request_id).await?;

await client.withdrawExchange(requestId);

await client.WithdrawExchangeAsync(requestId);

err := client.WithdrawExchange(requestID)

client.withdraw_exchange(&request_id).await?;

await client.revokePairing(routingToken);

await client.RevokePairingAsync(routingToken);

err := client.RevokePairing(routingToken)

client.revoke_pairing(&routing_token).await?;

cd src/typescript/test-enforcer
npm install
npx ts-node index.ts

cd src/dotnet/Airlock.Gateway.Sdk.TestEnforcer
dotnet run

cd src/go
go run ./cmd/test-enforcer

cd src/rust
cargo run --bin test_enforcer