vybekiit 0.4.0 → 0.6.0

package/dist/global-skills/use-railway/references/sandbox.md

@@ -0,0 +1,167 @@
+# Sandboxes
+
+Sandboxes are ephemeral remote Linux environments attached to a Railway project + environment. Use them when the user asks for a sandbox, a scratch/ephemeral environment, or wants to build or run something remotely without touching deployed services. Sandboxes link at the project level — a linked project and environment (or explicit `--project` / `--environment` flags) is enough; no service link is needed.
+
+## Availability — Priority Boarding required
+
+**Sandboxes must be enabled in Priority Boarding.** If sandbox commands fail with a feature-availability error from the API (the `PROJECT_SANDBOXES` feature is not enabled for the workspace), do not retry — prompt the user to enable Sandboxes through Priority Boarding in the Railway dashboard, then resume once they confirm.
+
+Two non-errors to expect:
+
+- Every sandbox command prints `Warning: Railway sandboxes are experimental and APIs may change or break during testing.` on stderr. This is informational — not a failure.
+- Context errors (`No project selected...` / `No environment selected...`) mean missing linking, not missing access: run `railway link` or pass `--project` and `--environment`.
+
+## Create and connect
+
+### Create a sandbox
+
+```bash
+railway sandbox create
+railway sandbox create --variable DB_URL=postgres.DATABASE_URL --env-file .env
+railway sandbox create --private-network --idle-timeout-minutes 60 --json
+```
+
+`create` boots a sandbox and remembers it as the **active sandbox** — later commands that take `--id` default to it. `--variable` values may reference other Railway variables (`postgres.DATABASE_URL` or the full `${{postgres.DATABASE_URL}}` form), resolved server-side at create time; `--variable` overrides `--env-file` entries with the same key. Sandboxes are isolated with public egress by default — pass `--private-network` when the sandbox must reach internal hosts like `postgres.railway.internal`. `--idle-timeout-minutes` auto-destroys the sandbox after that long idle; attached sessions send a heartbeat that keeps it alive. Prefer `--json` for parsing the created id.
+
+### Connect over SSH
+
+```bash
+railway sandbox ssh                      # interactive shell in the active sandbox
+railway sandbox ssh --id <sandbox-id> -- ls -la
+```
+
+Trailing `-- <command>` runs a single command instead of an interactive shell. `--session <name>` resumes a durable session by name.
+
+## Run commands remotely
+
+### One-off commands
+
+```bash
+railway sandbox exec -- npm test
+railway sandbox exec --id <sandbox-id> --timeout 120 -- ./integration.sh
+```
+
+Everything after `--` is the command. A single argument runs as a shell command; multiple arguments run as argv with quoting preserved. `--timeout <seconds>` is a client-side deadline — on expiry the command is terminated and the CLI exits 124 (GNU timeout convention), so treat exit 124 as "took too long", not "failed".
+
+### Long-running commands — detach and reattach
+
+```bash
+railway sandbox exec --detach -- npm run build   # prints a durable session name, exits
+railway sandbox exec --session <name>            # reattach and stream the output
+```
+
+`--detach` starts the command, prints its durable session name to stdout, and returns while the command keeps running — use it for builds or jobs longer than you want to block on. Reattach with `--session <name>`; add `--resume-from-last-read` to skip replaying retained scrollback. Durable sessions are not available on every sandbox — when the CLI warns `durable sessions are unavailable for this sandbox; ran attached`, the command still ran, just without reattach support.
+
+## Remote builds
+
+Use templates to run build steps remotely. Build steps execute server-side in a transient sandbox; the result is a content-addressed filesystem snapshot cached server-side, so re-running the same recipe is an instant cache hit.
+
+### Build remotely
+
+```bash
+railway sandbox template build --name ci -c 'npm ci' -c 'npm run build' --wait
+```
+
+`-c` is repeatable and runs in order; each step must exit 0 within 10 minutes. `--wait` polls until READY or FAILED. `--name` is a local-only handle for reuse.
+
+### Boot from the build
+
+```bash
+railway sandbox create --template ci             # boots from the cached snapshot
+railway sandbox exec -- npm start
+```
+
+Template recipes are stored locally by this CLI — `Unknown template` means it was built elsewhere or never built; rebuild it with the command the error message prints. For state that must be reachable from other machines or later sessions, capture a [checkpoint](#checkpoints--save-and-restore-sandbox-state) instead.
+
+## Agents in sandboxes
+
+Use sandboxes for agent runs that need isolated compute, private networking to Railway resources, or remote build/test execution. Copy or generate code in the sandbox, run the agent or test command with `sandbox exec`, and capture a checkpoint if the state should be reused across machines. Prefer `--private-network` when the agent needs internal service or database access.
+
+### Inspect templates
+
+```bash
+railway sandbox template status <id-or-name> --json
+railway sandbox template list --json
+```
+
+## Port forwarding
+
+```bash
+railway sandbox forward 3000              # localhost:3000 → sandbox port 3000
+railway sandbox forward 8080:3000 5432    # explicit local port; multiple ports per connection
+```
+
+If a requested local port is busy the CLI picks a nearby free one and says so — pass `--strict` to fail instead. The tunnel auto-reconnects with backoff if the relay drops while the sandbox is still running.
+
+## Fork a sandbox
+
+```bash
+railway sandbox fork                      # fork the active sandbox; the fork becomes active
+railway sandbox fork <sandbox-id> --variable FOO=bar --private-network
+```
+
+A fork copies the source's filesystem state but **does not inherit its variables or network mode** — re-pass `--variable`/`--env-file`/`--private-network` as needed.
+
+## Checkpoints — save and restore sandbox state
+
+Checkpoints are named disk snapshots captured from a running sandbox, stored server-side per environment. Use them to set a sandbox up once (clone a repo, install dependencies, seed data) and boot fresh sandboxes from that state later. Pick the right state mechanism:
+
+- **Template**: a reproducible recipe built from shell instructions — deterministic, but stored in this CLI's local store, so it only resolves on the machine that built it.
+- **Fork**: a live copy of a sandbox made right now.
+- **Checkpoint**: state you set up interactively, saved server-side by name — works from any machine or later agent session.
+
+### Capture
+
+```bash
+railway sandbox checkpoint create my-setup       # capture the active sandbox's disk
+railway sandbox checkpoint create my-setup --id <sandbox-id> --json
+```
+
+Capture is synchronous — the checkpoint is bootable as soon as the command returns, but flushing and uploading a large disk can take a while (the request honors `RAILWAY_HTTP_TIMEOUT`, so raise that rather than assuming a hang). Reusing a name **replaces the previous checkpoint without warning** — run `checkpoint list` first if overwriting matters. 64-character hex names are reserved for template hashes.
+
+### Boot from a checkpoint
+
+```bash
+railway sandbox create --checkpoint my-setup
+railway sandbox exec -- npm start
+```
+
+`--checkpoint` and `--template` are mutually exclusive. A checkpoint restores disk state only — variables and network mode are not part of the snapshot, so re-pass `--variable`/`--env-file`/`--private-network` on create as needed.
+
+### Manage checkpoints
+
+```bash
+railway sandbox checkpoint list --json
+railway sandbox checkpoint rename <name> <new-name>
+railway sandbox checkpoint delete <name>
+```
+
+Checkpoints are scoped to the environment: `list` shows only the linked environment's checkpoints, and `--checkpoint` resolves names within that scope. Deleting a checkpoint removes its underlying disk snapshot.
+
+## List and teardown
+
+```bash
+railway sandbox list --json               # also refreshes the local id cache
+railway sandbox list --all                # include destroyed sandboxes
+railway sandbox destroy                   # destroy the active sandbox
+railway sandbox destroy <sandbox-id>
+```
+
+Destroy sandboxes you created for a task once the task is done — idle timeout is the backstop, not the cleanup plan.
+
+## Troubleshoot sandboxes
+
+- **Feature-availability error from the API**: Sandboxes aren't enabled for this workspace. Prompt the user to enable Sandboxes through Priority Boarding in the Railway dashboard; don't retry until they confirm.
+- **`No project selected` / `No environment selected`**: run `railway link` or pass `--project` with `--environment`.
+- **`Unknown template ...`**: the recipe isn't in this CLI's local store — rebuild with `railway sandbox template build --name <name> -c '<command>' --wait`, or use a checkpoint if the state was meant to travel between machines.
+- **`Template build failed`**: a step exited non-zero or exceeded its 10-minute limit; fix that step and rebuild.
+- **`No checkpoint named ...`**: checkpoints are environment-scoped — confirm the linked environment and run `railway sandbox checkpoint list`; the checkpoint may live in another environment or have been deleted/replaced.
+- **Checkpoint capture times out**: a large disk is still uploading — raise `RAILWAY_HTTP_TIMEOUT` (seconds) and retry rather than treating it as a failure.
+- **Exit code 124 from `exec`**: the client-side `--timeout` expired — rerun with a larger timeout or `--detach`.
+- **`that session may have expired; the server started a fresh one instead`**: the durable session lapsed; the command ran in a new session — check whether prior state mattered.
+- **SSH/forward drops**: the CLI reconnects automatically while the sandbox is RUNNING; if it reports the sandbox STOPPED, create or fork a new one.
+
+## Validated against
+
+- Docs: [sandboxes.md](https://docs.railway.com/sandboxes), [sandbox.md](https://docs.railway.com/cli/sandbox), [agents-in-sandboxes.md](https://docs.railway.com/guides/agents-in-sandboxes)
+- CLI source: [sandbox.rs](https://github.com/railwayapp/cli/blob/v5.23.3/src/commands/sandbox.rs), [sandbox_exec.rs](https://github.com/railwayapp/cli/blob/v5.23.3/src/controllers/sandbox_exec.rs)

package/dist/global-skills/use-railway/references/setup.md

@@ -0,0 +1,364 @@
+# Setup
+
+Create, link, and organize Railway projects, services, databases, and workspaces.
+
+## Account creation & first-time onboarding
+
+A brand-new user with no Railway account is onboarded through the same unified OAuth flow as sign-in — the backend detects fresh accounts and adapts the consent + landing pages. Pick the command by intent:
+
+- **Deploy from the current directory** → `railway up` (interactive) or `railway up -y` (skips the confirm prompt). When unauthenticated it opens a browser to sign in / sign up, then creates a project + service and deploys. Run it yourself; do not ask the user to `railway login` first.
+- **New project from cwd when already signed in** → `railway up --new` (`--name <name>` to override the project name).
+- **Sign up with a deployable app in cwd → `railway up`** (signs up *and* deploys — bare `up` works for a detected agent, even if the user only said "sign me up"; add `-y` to skip prompts / force it non-interactively). Sign in, or sign up with nothing to deploy → `railway login` (creates new accounts on the fly).
+
+`railway up` and `railway login` self-validate auth — don't run `railway whoami` before them.
+
+**Headless / SSH / CI**: the CLI auto-detects these and switches to the device-code flow (RFC 8628: sign-in link + short code) on its own. Do NOT pass `--browserless` just because you are an agent — if the human is at this machine, bare `railway login` opens their browser and completes far more reliably. Reserve the flag for machines with genuinely no browser that the auto-detection missed.
+
+**`railway up --json` / `--ci` do NOT auto-prompt** an unauthed user. `--json` emits a structured `{"error":"Not signed in.","code":"NOT_AUTHENTICATED", ...}` on stdout and exits non-zero — detect `NOT_AUTHENTICATED`, run `railway login`, then retry.
+
+**Fully unattended (no human)**: set `RAILWAY_API_TOKEN` (account-scoped) or `RAILWAY_TOKEN` (project-scoped) instead of logging in. There is no headless account-creation path — a brand-new user needs a human at the browser once.
+
+## Projects
+
+### List and discover
+
+```bash
+railway project list --json        # projects in current workspace
+railway list --json                # all projects across workspaces with service metadata
+railway whoami --json              # current user, workspace memberships
+```
+
+### Link to an existing project
+
+Linking sets the working context for all subsequent CLI commands in this directory.
+
+```bash
+railway link --project <project-id-or-name>
+railway status --json              # confirm linked context
+```
+
+Without `--project`, `railway link` runs interactively. For scripted or CI use, always pass explicit flags.
+
+### Link to a specific service
+
+Switch the linked service within an already-linked project:
+
+```bash
+railway service link              # interactive service picker
+railway service link <name>       # link directly by name
+```
+
+### Create a new project
+
+```bash
+railway init --name <project-name>
+railway init --name <project-name> --workspace <workspace-id-or-name>
+```
+
+`railway init` both creates and links in one step. In CI or multi-workspace setups, pass `--workspace` explicitly to avoid ambiguity.
+
+### Update project settings
+
+Settings like project name, PR deploys, and visibility aren't exposed through the CLI. Use the GraphQL API helper (see [request.md](request.md)):
+
+```bash
+scripts/railway-api.sh \
+  'mutation updateProject($id: String!, $input: ProjectUpdateInput!) {
+    projectUpdate(id: $id, input: $input) { id name isPublic prDeploys }
+  }' \
+  '{"id":"<project-id>","input":{"name":"new-name","prDeploys":true}}'
+```
+
+## Services
+
+### List services
+
+Use `railway service list` for service discovery. It returns services in the current environment by default.
+
+```bash
+railway service list --json
+railway service list --project <project-id> --environment production --json
+```
+
+Prefer service IDs from JSON output when names may collide.
+
+### Create a service
+
+```bash
+railway add --service <name> --json           # empty service
+railway add --database postgres --json        # managed database (postgres, redis, mysql, mongo)
+railway add                                   # interactive only — do not use non-interactively
+```
+
+**Always pass `--json` to `railway add`.** Without it, a successful database create writes nothing to stdout — only a `> What do you need? Database` echo on stderr that looks identical to a stalled interactive prompt. Retrying based on "no stdout came back" silently provisions a second database. With `--json`, success prints `{"serviceId":"…","serviceName":"…"}` and failure exits non-zero.
+
+**`--database` is cumulative, not last-wins.** `railway add --database postgres --database redis` creates *both* in a single call. Don't repeat the flag — issue one `railway add` per database.
+
+**If `railway add` output looks ambiguous, never retry blind.** Run `railway service list --json` (or query `project.services` via [request.md](request.md)) first and compare against what you expected to exist. Treat the service list as the source of truth, not the CLI's stdout shape.
+
+Before adding a database — and before retrying any `railway add` whose output you can't interpret — list existing services to avoid duplicates. Run `railway service list --json` for a fast count, or `railway environment config --json` and inspect `source.image` per service when you need to identify the engine:
+
+| Image pattern | Database |
+|---|---|
+| `ghcr.io/railway/postgres*` or `postgres:*` | Postgres |
+| `ghcr.io/railway/redis*` or `redis:*` | Redis |
+| `ghcr.io/railway/mysql*` or `mysql:*` | MySQL |
+| `ghcr.io/railway/mongo*` or `mongo:*` | MongoDB |
+
+If a matching database already exists, skip creation and wire the existing service's variables to the app.
+
+Empty services have no source until you configure one. This is the right pattern when you need to set source repo, branch, or build config before the first deploy.
+
+### Connect a database to a service
+
+After `railway add --database <type>`, the database creates connection variables automatically. Wire them to your app service using variable references:
+
+| Database | Connection variable |
+|---|---|
+| Postgres | `${{Postgres.DATABASE_URL}}` |
+| Redis | `${{Redis.REDIS_URL}}` |
+| MySQL | `${{MySQL.MYSQL_URL}}` |
+| MongoDB | `${{MongoDB.MONGO_URL}}` |
+
+```bash
+railway variable set DATABASE_URL='${{Postgres.DATABASE_URL}}' --service <app-service>
+```
+
+Service names in variable references are case-sensitive and must match exactly. For full wiring details including public/private networking decisions, see [configure.md](configure.md).
+
+When creating new service instances via JSON config patches, include `isCreated: true` in the service block to mark it as a new service.
+
+### Connect to a database shell
+
+Use `railway connect` when the user wants an interactive database shell (`psql`, `redis-cli`, `mysql`, or `mongosh`):
+
+```bash
+railway connect <database-service>
+railway connect <database-service> --environment production
+railway connect <database-service> --project <project-id> --environment production
+railway connect <database-service> --ssh
+railway connect <database-service> --no-ssh
+```
+
+The local database client must be installed. By default, `connect` uses a public TCP proxy when one exists and falls back to an SSH tunnel when no public proxy URL is available. Use `--ssh` to force the tunnel path, or `--no-ssh` to require a public TCP proxy.
+
+### Delete a service
+
+Deleting a service removes it from the target environment. Confirm with the user before running it.
+
+```bash
+railway service delete --service <service> --environment <env> --yes --json
+railway service delete --service <service-id> --project <project-id> --environment <env> --yes --json
+```
+
+If 2FA is enabled and the command runs non-interactively, pass `--2fa-code <code>`.
+
+### Deploy from a template
+
+Templates provision pre-configured services with sensible defaults, faster than creating an empty service and configuring it manually. Use `templates search` for marketplace discovery and `deploy --template` for deployment:
+
+```bash
+railway templates search postgres --verified true --json
+railway templates search --category Storage --limit 10 --json
+railway templates search postgres --limit 50 --after <cursor> --json
+railway deploy --template <template-code>
+```
+
+The template search command doesn't require authentication. Use the `code` from the JSON results with `railway deploy --template <template-code>`.
+
+Template deployments typically create:
+
+- A service with pre-configured image or source
+- Environment variables (connection strings, secrets)
+- A volume for persistent data (databases)
+- A TCP proxy for external access (where applicable)
+
+Manage owned templates with:
+
+```bash
+railway templates list --json
+railway templates list --workspace <workspace> --json
+railway templates create --project <project> --environment production --json
+railway templates publish <template-id> --category Other --description "Deploy and Host My App with Railway" --readme-file README.md --json
+railway templates update <template-id> --category Other --description "Updated description" --readme-file README.md --json
+railway templates unpublish <template-id-or-code> --yes --json
+railway templates delete <template-id-or-code> --yes --json
+```
+
+Non-interactive `unpublish` and `delete` require `--yes`; pass `--2fa-code` when required by the current auth session.
+
+### Bootstrap source for an empty service
+
+After creating an empty service, wire it to a repo:
+
+```bash
+railway environment edit --service-config <service> source.repo <repo-url>
+railway environment edit --service-config <service> source.branch <branch>
+```
+
+### Deploy a Docker image
+
+When you have a built image (for example, from a private registry or Docker Hub), skip source builds entirely:
+
+```bash
+railway environment edit --service-config <service> source.image <image:tag>
+```
+
+This sets the service to pull from a container registry instead of building from source.
+
+## Buckets
+
+Buckets are S3-compatible object storage. They are created at the project level and deployed to environments via config patches.
+
+### List buckets
+
+```bash
+railway bucket list --json                                # buckets in current environment
+railway bucket list --environment production --json       # buckets in a specific environment
+```
+
+### Create a bucket
+
+```bash
+railway bucket create my-bucket --region sjc              # create with name and region
+railway bucket create --region iad --json                 # auto-named, JSON output
+```
+
+Available regions:
+
+| Code | Location |
+|---|---|
+| `sjc` | US West (California) |
+| `iad` | US East (Virginia) |
+| `ams` | EU West (Amsterdam) |
+| `sin` | Asia Pacific (Singapore) |
+
+Without `--region`, the CLI prompts interactively. For scripted use, always pass `--region`.
+
+### Delete a bucket
+
+Deletion is permanent and destroys all objects in the bucket.
+
+```bash
+railway bucket delete --bucket my-bucket --yes            # non-interactive
+railway bucket delete --bucket my-bucket --yes --2fa-code 123456   # with 2FA
+```
+
+### Rename a bucket
+
+```bash
+railway bucket rename --bucket my-bucket --name new-name --json
+```
+
+### Bucket info
+
+Check storage usage and object count:
+
+```bash
+railway bucket info --bucket my-bucket --json
+```
+
+Returns storage size (bytes), object count, region, and environment.
+
+### Bucket credentials
+
+Get S3-compatible credentials for connecting your app to a bucket:
+
+```bash
+railway bucket credentials --bucket my-bucket --json
+```
+
+Returns: `endpoint`, `accessKeyId`, `secretAccessKey`, `bucketName`, `region`, `urlStyle`.
+
+Without `--json`, output uses `AWS_*=value` lines suitable for `eval $(railway bucket credentials)` or piping into `.env` files.
+
+To reset credentials (invalidates existing ones):
+
+```bash
+railway bucket credentials --bucket my-bucket --reset --yes
+railway bucket credentials --bucket my-bucket --reset --yes --2fa-code 123456  # with 2FA
+```
+
+### Connect a bucket to a service
+
+After creating a bucket, wire the S3 credentials to your app service as environment variables:
+
+```bash
+# Get credentials
+railway bucket credentials --bucket my-bucket --json
+
+# Set them on your app service
+railway variable set \
+  AWS_ENDPOINT_URL=<endpoint> \
+  AWS_ACCESS_KEY_ID=<access-key> \
+  AWS_SECRET_ACCESS_KEY=<secret-key> \
+  AWS_S3_BUCKET_NAME=<bucket-name> \
+  AWS_DEFAULT_REGION=<region> \
+  --service <app-service>
+```
+
+All subcommands support `--bucket (-b)` and `--environment (-e)` as global flags to skip interactive prompts.
+
+## Analyze codebase before setup
+
+When setting up a new service from source, detect the project type from marker files:
+
+| Marker file | Type |
+|---|---|
+| `package.json` | Node.js |
+| `requirements.txt` or `pyproject.toml` | Python |
+| `go.mod` | Go |
+| `Cargo.toml` | Rust |
+| `index.html` (no package.json) | Static site |
+
+### Monorepo detection
+
+| Marker | Monorepo type |
+|---|---|
+| `pnpm-workspace.yaml` | pnpm workspace (shared) |
+| `package.json` with `workspaces` field | npm/yarn workspace (shared) |
+| `turbo.json` | Turborepo (shared) |
+| Multiple subdirectories with separate `package.json`, no workspace config | Isolated monorepo |
+
+**Isolated monorepo** (apps don't share code): set `rootDirectory` to the app's subdirectory (for example, `/apps/api`).
+
+**Shared monorepo** (TypeScript workspaces, shared packages): do not set `rootDirectory`. Set custom build and start commands instead:
+
+- pnpm: `pnpm --filter <package> build`
+- npm: `npm run build --workspace=packages/<package>`
+- yarn: `yarn workspace <package> build`
+- Turborepo: `turbo run build --filter=<package>`
+
+### Scaffolding hints
+
+When no code exists, minimal starting points for common types:
+
+- **Static site**: create `index.html` in the root directory.
+- **Vite React**: `npm create vite@latest . -- --template react`
+- **Python FastAPI**: create `main.py` with a FastAPI app and `requirements.txt` with `fastapi` and `uvicorn`.
+- **Go**: create `main.go` with an HTTP server that reads `PORT` from the environment.
+
+## Workspaces
+
+Workspaces scope billing and team access. Most users have one personal workspace and possibly team workspaces.
+
+```bash
+railway whoami --json              # lists workspace memberships
+```
+
+When creating projects, Railway uses the default workspace unless `--workspace` is specified.
+
+## Troubleshoot setup issues
+
+- **CLI missing**: install via `brew install railway` or `bash <(curl -fsSL https://railway.com/install.sh)`
+- **Not authenticated**: `railway login`
+- **Project not found**: verify with `railway project list --json`, check workspace context
+- **Service not found**: `railway service list --json` to list services in the current environment
+- **Database shell cannot connect**: install the local database client, use `railway connect <service> --ssh`, or create/check a TCP proxy
+- **Wrong workspace**: inspect `railway whoami --json`, re-run with explicit `--workspace`
+- **Permission denied**: check workspace role, mutations require member or admin access
+
+## Validated against
+
+- Docs: [cli.md](https://docs.railway.com/cli), [init.md](https://docs.railway.com/cli/init), [add.md](https://docs.railway.com/cli/add), [link.md](https://docs.railway.com/cli/link), [project.md](https://docs.railway.com/cli/project), [service.md](https://docs.railway.com/cli/service), [connect.md](https://docs.railway.com/cli/connect), [templates.md](https://docs.railway.com/cli/templates), [list.md](https://docs.railway.com/cli/list), [whoami.md](https://docs.railway.com/cli/whoami)
+- CLI source: [init.rs](https://github.com/railwayapp/cli/blob/v5.23.3/src/commands/init.rs), [add.rs](https://github.com/railwayapp/cli/blob/v5.23.3/src/commands/add.rs), [project.rs](https://github.com/railwayapp/cli/blob/v5.23.3/src/commands/project.rs), [service.rs](https://github.com/railwayapp/cli/blob/v5.23.3/src/commands/service.rs), [connect.rs](https://github.com/railwayapp/cli/blob/v5.23.3/src/commands/connect.rs), [templates.rs](https://github.com/railwayapp/cli/blob/v5.23.3/src/commands/templates.rs), [list.rs](https://github.com/railwayapp/cli/blob/v5.23.3/src/commands/list.rs), [bucket.rs](https://github.com/railwayapp/cli/blob/v5.23.3/src/commands/bucket.rs)