Environments

boat env set base --safe-for-third-parties true

curl -sS -X PUT "$BOAT_API_BASE/environments/$ENV_ID" \
  -H "Authorization: Bearer $BOAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"safeForThirdParties":true}'

await sandbox.updateEnvironment({
  environmentId: envId,
  updateSandboxEnvironmentRequest: { safeForThirdParties: true },
});

sandbox.update_environment(env_id, UpdateSandboxEnvironmentRequest(safe_for_third_parties=True))

boat env set base --github true --secrets true --sandbox-credentials false --agents-credentials true

curl -sS -X PUT "$BOAT_API_BASE/environments/$ENV_ID" \
  -H "Authorization: Bearer $BOAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"passGithub":true,"passSecrets":true,"passSandboxCredentials":false,"passAgentsCredentials":true}'

await sandbox.updateEnvironment({
  environmentId: envId,
  updateSandboxEnvironmentRequest: {
    passGithub: true,
    passSecrets: true,
    passSandboxCredentials: false,
    passAgentsCredentials: true,
  },
});

sandbox.update_environment(env_id, UpdateSandboxEnvironmentRequest(
    pass_github=True,
    pass_secrets=True,
    pass_sandbox_credentials=False,
    pass_agents_credentials=True,
))

boat env add-repo base octocat/hello-world --branch develop
boat env rm-repo base octocat/hello-world

repo_id=$(curl -sS "$BOAT_API_BASE/repos?sync=true&q=hello-world" \
  -H "Authorization: Bearer $BOAT_API_KEY" \
  | jq -r '.installations[0].repositories[0].databaseId')

curl -sS -X POST "$BOAT_API_BASE/repos" \
  -H "Authorization: Bearer $BOAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"repositoryId\":\"$repo_id\",\"baseBranch\":\"develop\"}"

const repos = await sandbox.repos({ sync: true, q: "hello-world" });
const repo = repos.installations.flatMap((i) => i.repositories)[0];

await sandbox.selectRepo({
  repoSelectionRequest: { repositoryId: repo.databaseId, baseBranch: "develop" },
});

from boat_sdk.models.repo_selection_request import RepoSelectionRequest

repos = sandbox.repos(sync=True, q="hello-world")
repo = repos.installations[0].repositories[0]

sandbox.select_repo(RepoSelectionRequest(repository_id=repo.database_id, base_branch="develop"))

boat env set-var base STRIPE_KEY=sk_live_123
boat env rm-var base STRIPE_KEY
boat env set-file base backend/.env --from ./local.env
cat ./local.env | boat env set-file base backend/.env
boat env rm-file base backend/.env

curl -sS -X POST "$BOAT_API_BASE/secrets" \
  -H "Authorization: Bearer $BOAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"envContents":"STRIPE_KEY=sk_live_123\n","secretFiles":[{"path":"backend/.env","contents":"DATABASE_URL=postgres://...\n"}]}'

// default environment
await sandbox.updateSecrets({
  secretsUpdateRequest: {
    envContents: "STRIPE_KEY=sk_live_123\n",
    secretFiles: [
      { path: "backend/.env", contents: "DATABASE_URL=postgres://...\n" },
    ],
  },
});

// any named environment
await sandbox.updateEnvironment({
  environmentId: envId,
  updateSandboxEnvironmentRequest: {
    envContents: "STRIPE_KEY=sk_live_123\n",
    secretFiles: [{ path: "backend/.env", contents: "DATABASE_URL=postgres://...\n" }],
  },
});

from boat_sdk.models.secret_file import SecretFile
from boat_sdk.models.secrets_update_request import SecretsUpdateRequest

# default environment
sandbox.update_secrets(SecretsUpdateRequest(
    env_contents="STRIPE_KEY=sk_live_123\n",
    secret_files=[SecretFile(path="backend/.env", contents="DATABASE_URL=postgres://...\n")],
))

# any named environment
sandbox.update_environment(env_id, UpdateSandboxEnvironmentRequest(
    env_contents="STRIPE_KEY=sk_live_123\n",
    secret_files=[SecretFile(path="backend/.env", contents="DATABASE_URL=postgres://...\n")],
))

boat new --env DATABASE_URL=postgres://... --env FEATURE_FLAG=1

curl -sS -X POST "$BOAT_API_BASE/sandboxes" \
  -H "Authorization: Bearer $BOAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"ttlSeconds":3600,"env":{"DATABASE_URL":"postgres://...","FEATURE_FLAG":"1"}}'

await sandbox.create({
  createSandboxRequest: {
    ttlSeconds: 3600,
    env: { DATABASE_URL: "postgres://...", FEATURE_FLAG: "1" },
  },
});

sandbox.create(CreateSandboxRequest(
    ttl_seconds=3600,
    env={"DATABASE_URL": "postgres://...", "FEATURE_FLAG": "1"},
))

boat env list
boat env info staging
boat env new staging
boat env rename staging prod
boat env default prod
boat env rm staging
boat env upgrade prod

curl -sS "$BOAT_API_BASE/environments" -H "Authorization: Bearer $BOAT_API_KEY"

curl -sS -X POST "$BOAT_API_BASE/environments" \
  -H "Authorization: Bearer $BOAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"staging"}'

curl -sS -X PUT "$BOAT_API_BASE/environments/$ENV_ID" \
  -H "Authorization: Bearer $BOAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"prod","isDefault":true,"safeForThirdParties":true}'

curl -sS -X POST "$BOAT_API_BASE/environments/$ENV_ID/upgrade" \
  -H "Authorization: Bearer $BOAT_API_KEY"

curl -sS -X DELETE "$BOAT_API_BASE/environments/$ENV_ID" \
  -H "Authorization: Bearer $BOAT_API_KEY"

const { environments } = await sandbox.environments();
const staging = await sandbox.createEnvironment({
  createSandboxEnvironmentRequest: { name: "staging" },
});

await sandbox.updateEnvironment({
  environmentId: envId,
  updateSandboxEnvironmentRequest: { name: "prod", isDefault: true, safeForThirdParties: true },
});

await sandbox.upgradeEnvironment({ environmentId: envId });
await sandbox.deleteEnvironment({ environmentId: envId });

from boat_sdk.models.create_sandbox_environment_request import CreateSandboxEnvironmentRequest
from boat_sdk.models.update_sandbox_environment_request import UpdateSandboxEnvironmentRequest

envs = sandbox.environments()
staging = sandbox.create_environment(CreateSandboxEnvironmentRequest(name="staging"))

sandbox.update_environment(env_id, UpdateSandboxEnvironmentRequest(
    name="prod", is_default=True, safe_for_third_parties=True,
))

sandbox.upgrade_environment(env_id)
sandbox.delete_environment(env_id)

boat new --environment staging
boat resume bx_f7k2q9hd --environment staging
boat fork bx_f7k2q9hd --environment staging

curl -sS -X POST "$BOAT_API_BASE/sandboxes" \
  -H "Authorization: Bearer $BOAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"ttlSeconds":3600,"environment":"staging"}'

await sandbox.create({ createSandboxRequest: { ttlSeconds: 3600, environment: "staging" } });
await sandbox.resume({ sandboxId, resumeRequest: { environment: "staging" } });
await sandbox.fork({ sandboxId, forkRequest: { environment: "staging" } });

sandbox.create(CreateSandboxRequest(ttl_seconds=3600, environment="staging"))
sandbox.resume(sandbox_id, ResumeRequest(environment="staging"))
sandbox.fork(sandbox_id, ForkRequest(environment="staging"))