@ivannxbt/ai-config 0.1.0

package/.cursor/skills/use-railway/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: use-railway
+description: >
+  Operate Railway infrastructure: create projects, provision services and
+  databases, deploy code, configure environments and variables, manage domains,
+  troubleshoot failures, check status and metrics, and query Railway docs. Use
+  this skill whenever the user mentions Railway, deployments, services,
+  environments, build failures, or infrastructure operations, even if they don't
+  say "Railway" explicitly.
+allowed-tools: Bash(railway:*), Bash(which:*), Bash(command:*), Bash(npm:*), Bash(npx:*), Bash(curl:*)
+---
+
+# Use Railway
+
+## Railway resource model
+
+Railway organizes infrastructure in a hierarchy:
+
+- **Workspace** is the billing and team scope. A user belongs to one or more workspaces.
+- **Project** is a collection of services under one workspace. It maps to one deployable unit of work.
+- **Environment** is an isolated configuration plane inside a project (for example, `production`, `staging`). Each environment has its own variables, config, and deployment history.
+- **Service** is a single deployable unit inside a project. It can be an app from a repo, a Docker image, or a managed database.
+- **Deployment** is a point-in-time release of a service in an environment. It has build logs, runtime logs, and a status lifecycle.
+
+Most CLI commands operate on the linked project/environment/service context. Use `railway status --json` to see the context, and `--project`, `--environment`, `--service` flags to override.
+
+## Preflight
+
+Before any mutation, verify context:
+
+```bash
+command -v railway                # CLI installed
+railway whoami --json             # authenticated
+railway --version                 # check CLI version
+railway status --json             # linked project/environment/service
+```
+
+If the CLI is missing, guide the user to install it. 
+
+```bash
+bash <(curl -fsSL cli.new) # Shell script (macOS, Linux, Windows via WSL)
+brew install railway # Homebrew (macOS)
+npm i -g @railway/cli # npm (macOS, Linux, Windows). Requires Node.js version 16 or higher.
+```
+
+If not authenticated, run `railway login`. If not linked, run `railway link --project <id-or-name>`.
+
+If a command is not recognized (for example, `railway environment edit`), the CLI may be outdated. Upgrade with:
+
+```bash
+railway upgrade
+```
+
+## Common quick operations
+
+These are frequent enough to handle without loading a reference:
+
+```bash
+railway status --json                                    # current context
+railway whoami --json                                    # auth and workspace info
+railway project list --json                              # list projects
+railway service status --all --json                      # all services in current context
+railway variable list --service <svc> --json             # list variables
+railway variable set KEY=value --service <svc>           # set a variable
+railway logs --service <svc> --lines 200 --json          # recent logs
+railway up --detach -m "<summary>"                       # deploy current directory
+```
+
+## Routing
+
+For anything beyond quick operations, load the reference that matches the user's intent. Load only what you need, one reference is usually enough, two at most.
+
+| Intent | Reference | Use for |
+|---|---|---|
+| Create or connect resources | [setup.md](references/setup.md) | Projects, services, databases, templates, workspaces |
+| Ship code or manage releases | [deploy.md](references/deploy.md) | Deploy, redeploy, restart, build config, monorepo, Dockerfile |
+| Change configuration | [configure.md](references/configure.md) | Environments, variables, config patches, domains, networking |
+| Check health or debug failures | [operate.md](references/operate.md) | Status, logs, metrics, build/runtime triage, recovery |
+| Request from API, docs, or community | [request.md](references/request.md) | Railway GraphQL API queries/mutations, metrics queries, Central Station, official docs |
+
+If the request spans two areas (for example, "deploy and then check if it's healthy"), load both references and compose one response.
+
+## Execution rules
+
+1. Prefer Railway CLI. Fall back to `scripts/railway-api.sh` for operations the CLI doesn't expose.
+2. Use `--json` output where available for reliable parsing.
+3. Resolve context before mutation. Know which project, environment, and service you're acting on.
+4. For destructive actions (delete service, remove deployment, drop database), confirm intent and state impact before executing.
+5. After mutations, verify the result with a read-back command.
+
+## Composition patterns
+
+Multi-step workflows follow natural chains:
+
+- **First deploy**: setup (create project + service), configure (set variables and source), deploy, operate (verify healthy)
+- **Fix a failure**: operate (triage logs), configure (fix config/variables), deploy (redeploy), operate (verify recovery)
+- **Add a domain**: configure (add domain + set port), operate (verify DNS and service health)
+- **Docs to action**: request (fetch docs answer), route to the relevant operational reference
+
+When composing, return one unified response covering all steps. Don't ask the user to invoke each step separately.
+
+## Setup decision flow
+
+When the user wants to create or deploy something, determine the right action from current context:
+
+1. Run `railway status --json` in the current directory.
+2. **If linked**: add a service to the existing project (`railway add --service <name>`). Do not create a new project unless the user explicitly says "new project" or "separate project".
+3. **If not linked**: check the parent directory (`cd .. && railway status --json`).
+   - **Parent linked**: this is likely a monorepo sub-app. Add a service and set `rootDirectory` to the sub-app path.
+   - **Parent not linked**: run `railway list --json` and look for a project matching the directory name.
+     - **Match found**: link to it (`railway link --project <name>`).
+     - **No match**: create a new project (`railway init --name <name>`).
+4. When multiple workspaces exist, match by name from `railway whoami --json`.
+
+**Naming heuristic**: app names like "flappy-bird" or "my-api" are service names, not project names. Use the directory or repo name for the project.
+
+## Response format
+
+For all operational responses, return:
+1. What was done (action and scope).
+2. The result (IDs, status, key output).
+3. What to do next (or confirmation that the task is complete).
+
+Keep output concise. Include command evidence only when it helps the user understand what happened.

package/.cursor/skills/use-railway/references/configure.md

@@ -0,0 +1,283 @@
+# Configure
+
+Manage environments, variables, service config, domains, and networking.
+
+## Environments
+
+### List and switch
+
+```bash
+railway environment list --json
+railway environment link <environment>           # switch active environment
+```
+
+### Create
+
+```bash
+railway environment new <name>
+railway environment new <name> --duplicate <source-environment>    # clone config from existing
+```
+
+Duplicating copies all service configurations and variables from the source environment.
+
+## Variables
+
+### Read, set, and delete
+
+```bash
+railway variable list --service <service> --environment <env> --json
+railway variable set KEY=value --service <service> --environment <env>
+railway variable delete KEY --service <service> --environment <env>
+```
+
+Variable changes trigger a redeployment by default. This is usually the desired behavior, since the service picks up the values on restart.
+
+### Template syntax
+
+Railway supports interpolation between services and shared variables:
+
+```text
+${{KEY}}                                         # same-service variable
+${{shared.API_KEY}}                              # shared variable
+${{postgres.DATABASE_URL}}                       # variable from another service
+${{api.RAILWAY_PRIVATE_DOMAIN}}                  # another service's private domain
+```
+
+Wiring example, a frontend connecting to a backend over private networking:
+
+```text
+BACKEND_URL=http://${{api.RAILWAY_PRIVATE_DOMAIN}}:${{api.PORT}}
+```
+
+### Wiring services together
+
+Each managed database creates connection variables automatically. Reference them from other services using template syntax:
+
+| Database | Variable reference |
+|---|---|
+| Postgres | `${{Postgres.DATABASE_URL}}` |
+| Redis | `${{Redis.REDIS_URL}}` |
+| MySQL | `${{MySQL.MYSQL_URL}}` |
+| MongoDB | `${{MongoDB.MONGO_URL}}` |
+
+Service names in references are case-sensitive and must match the service name exactly as it appears in the project.
+
+**Public vs private networking decision:**
+
+| Traffic path | Use |
+|---|---|
+| Browser → API | Public domain |
+| Service → Service | Private domain (`RAILWAY_PRIVATE_DOMAIN`) |
+| Service → Database | Private (automatic, uses internal DNS) |
+
+**Frontend apps cannot use private networking.** Frontends run in the user's browser, not on Railway's network. They cannot reach `RAILWAY_PRIVATE_DOMAIN` or internal database URLs. Options:
+
+1. **Backend proxy** (recommended): frontend calls a backend API on a public domain, backend connects to the database over the private network.
+2. **Public database URL**: use the public connection variable (for example, `${{Postgres.DATABASE_PUBLIC_URL}}`). This requires a TCP proxy on the database service and exposes the database to the internet — only appropriate for development or low-sensitivity data.
+
+### Railway-provided variables
+
+These are set automatically at runtime. Availability depends on resource configuration.
+
+**Networking:**
+
+| Variable | Available when |
+|---|---|
+| `RAILWAY_PUBLIC_DOMAIN` | Public domain is configured |
+| `RAILWAY_PRIVATE_DOMAIN` | Always (internal DNS for service-to-service traffic) |
+| `RAILWAY_TCP_PROXY_DOMAIN` | TCP proxy is enabled |
+| `RAILWAY_TCP_PROXY_PORT` | TCP proxy is enabled |
+
+**Context:**
+
+| Variable | Available when |
+|---|---|
+| `RAILWAY_PROJECT_ID` | Always |
+| `RAILWAY_ENVIRONMENT_ID` | Always |
+| `RAILWAY_ENVIRONMENT_NAME` | Always |
+| `RAILWAY_SERVICE_ID` | Always |
+| `RAILWAY_SERVICE_NAME` | Always |
+| `RAILWAY_DEPLOYMENT_ID` | Always |
+| `RAILWAY_REPLICA_ID` | Replicas configured |
+| `RAILWAY_REPLICA_REGION` | Multi-region configured |
+
+**Git (present when deployed from a linked repo):**
+
+| Variable | Description |
+|---|---|
+| `RAILWAY_GIT_COMMIT_SHA` | Full commit hash of the deployed revision |
+| `RAILWAY_GIT_AUTHOR` | Commit author name |
+| `RAILWAY_GIT_COMMIT_MESSAGE` | First line of the commit message |
+| `RAILWAY_GIT_BRANCH` | Branch that triggered the deploy |
+
+**Storage (present when a volume is attached):**
+
+| Variable | Description |
+|---|---|
+| `RAILWAY_VOLUME_MOUNT_PATH` | Filesystem path where the volume is mounted |
+| `RAILWAY_VOLUME_NAME` | Name of the attached volume |
+
+Sealed variables are write-only. Their values don't appear in CLI output.
+
+## Service config
+
+Service configuration controls source, build, deploy, and networking settings. There are two ways to mutate it.
+
+### Dot-path patch
+
+For single-field changes:
+
+```bash
+railway environment edit --service-config <service> deploy.startCommand "npm start"
+railway environment edit --service-config <service> build.buildCommand "npm run build"
+railway environment edit --service-config <service> source.rootDirectory "/apps/api"
+railway environment edit --service-config <service> deploy.numReplicas 2
+```
+
+### JSON patch
+
+For multi-field changes or complex structures:
+
+```bash
+railway environment edit --json <<'JSON'
+{"services":{"<service-id>":{"build":{"buildCommand":"npm run build"},"deploy":{"startCommand":"npm start"}}}}
+JSON
+```
+
+Resolve exact service IDs from `railway status --json` before constructing JSON patches. Using names in the JSON payload doesn't work.
+
+### Config schema (typed paths)
+
+Include only keys you're changing. The full shape:
+
+**Source**: `source.image` (string), `source.repo` (string), `source.branch` (string), `source.rootDirectory` (string), `source.checkSuites` (boolean), `source.commitSha` (string), `source.autoUpdates.type` (string: `disabled`, `patch`, `minor`)
+
+**Build**: `build.builder` (string: `RAILPACK`, `NIXPACKS`, `DOCKERFILE`), `build.buildCommand` (string), `build.dockerfilePath` (string), `build.watchPatterns` (string array), `build.nixpacksConfigPath` (string)
+
+**Deploy**: `deploy.startCommand` (string), `deploy.preDeployCommand` (string), `deploy.healthcheckPath` (string), `deploy.healthcheckTimeout` (integer), `deploy.numReplicas` (integer), `deploy.restartPolicyType` (string: `ON_FAILURE`, `ALWAYS`, `NEVER`), `deploy.restartPolicyMaxRetries` (integer), `deploy.sleepApplication` (boolean), `deploy.cronSchedule` (string), `deploy.multiRegionConfig` (object)
+
+**Multi-region config** structure for `deploy.multiRegionConfig`:
+
+```json
+{ "us-west2": { "numReplicas": 2 }, "europe-west4-drams3a": { "numReplicas": 1 } }
+```
+
+| Region identifier | Location |
+|---|---|
+| `us-west2` | US West (Oregon) |
+| `us-east4-eqdc4a` | US East (Virginia) |
+| `europe-west4-drams3a` | Europe (Netherlands) |
+| `asia-southeast1-eqsg3a` | Asia (Singapore) |
+
+Natural language mapping: "add replicas in Europe" → `europe-west4-drams3a`, "US East" → `us-east4-eqdc4a`. When the user doesn't specify a region, query current config first with `railway environment config --json` to see existing region assignments before modifying.
+
+**Variables**: `variables.<KEY>.value` (string), `variables.<KEY>.isOptional` (boolean), `variables.<KEY>.isSealed` (boolean). Delete a variable by setting it to `null`.
+
+**Lifecycle**: `isDeleted` (boolean) removes the service. `isCreated` (boolean) marks as new.
+
+**Storage**: `volumeMounts.<volume-id>.mountPath` (string), `volumes.<volume-id>.isDeleted` (boolean)
+
+### Shared variables and project-level config
+
+```bash
+railway environment edit --json <<'JSON'
+{"sharedVariables":{"API_BASE":{"value":"https://example.com"}}}
+JSON
+```
+
+Shared variables are accessible from any service via `${{shared.KEY}}`.
+
+### Read config
+
+Always inspect before mutating. Config patches merge, so you need to know the state to avoid overwriting fields unintentionally:
+
+```bash
+railway environment config --json
+```
+
+Verify after mutation to confirm the change took effect:
+
+```bash
+railway environment config --json
+railway service status --all --json
+```
+
+## Domains
+
+### Railway domain
+
+One Railway-provided domain per service, generated automatically:
+
+```bash
+railway domain --service <service> --json
+```
+
+### Custom domain
+
+```bash
+railway domain example.com --service <service> --json
+```
+
+This returns the DNS records you need to configure at your DNS provider. Multiple custom domains per service are supported.
+
+### Target port
+
+If the service listens on a non-default port:
+
+```bash
+railway domain example.com --service <service> --port 8080 --json
+```
+
+### Private networking
+
+For service-to-service traffic within a project, use private domain references instead of public URLs. This avoids egress and is faster:
+
+```text
+BACKEND_URL=http://${{api.RAILWAY_PRIVATE_DOMAIN}}:${{api.PORT}}
+```
+
+### Read current domains
+
+Domain configuration lives in `config.services.<service-id>.networking` under `serviceDomains` (Railway-provided) and `customDomains`. Inspect with:
+
+```bash
+railway environment config --json
+```
+
+### Remove a domain
+
+Remove domains via JSON config patch by setting the domain ID to `null`:
+
+**Remove a custom domain:**
+
+```bash
+railway environment edit --json <<'JSON'
+{"services":{"<service-id>":{"networking":{"customDomains":{"<domain-id>":null}}}}}
+JSON
+```
+
+**Remove a Railway-provided domain:**
+
+```bash
+railway environment edit --json <<'JSON'
+{"services":{"<service-id>":{"networking":{"serviceDomains":{"<domain-id>":null}}}}}
+JSON
+```
+
+Get the domain IDs from `railway environment config --json` under the service's `networking` object.
+
+## Troubleshoot configuration
+
+- **Invalid dot-path**: check field names and types in the config schema section above
+- **Wrong service key in JSON patch**: resolve service IDs from `railway status --json`
+- **Variable change didn't take effect**: verify with `railway variable list`, changes trigger redeploy by default
+- **Domain returns errors**: verify the service has a healthy deployment and the target port is correct
+- **DNS propagation delay**: custom domains take time to propagate, this is normal
+- **Cloudflare proxy issues**: align SSL/TLS mode per Railway's domain guidance
+- **Private networking failing**: verify the service is listening on the referenced port and that the private domain variable reference is correct
+- **Multi-region patch ignored**: verify region names match the exact identifiers (`us-west2`, `us-east4-eqdc4a`, `europe-west4-drams3a`, `asia-southeast1-eqsg3a`)
+
+## Validated against
+
+- Docs: [environment.md](https://docs.railway.com/cli/environment), [variable.md](https://docs.railway.com/cli/variable), [variables.md](https://docs.railway.com/variables), [domains.md](https://docs.railway.com/networking/domains), [public-networking.md](https://docs.railway.com/networking/public-networking), [private-networking.md](https://docs.railway.com/networking/private-networking)
+- CLI source: [environment/mod.rs](https://github.com/railwayapp/cli/blob/a8a5afe/src/commands/environment/mod.rs), [environment/edit.rs](https://github.com/railwayapp/cli/blob/a8a5afe/src/commands/environment/edit.rs), [variable.rs](https://github.com/railwayapp/cli/blob/a8a5afe/src/commands/variable.rs), [domain.rs](https://github.com/railwayapp/cli/blob/a8a5afe/src/commands/domain.rs), [controllers/config/patch.rs](https://github.com/railwayapp/cli/blob/a8a5afe/src/controllers/config/patch.rs)

package/.cursor/skills/use-railway/references/deploy.md

@@ -0,0 +1,184 @@
+# Deploy
+
+Ship code, manage releases, and configure builds.
+
+## Deploy code
+
+### Standard deploy
+
+```bash
+railway up --detach -m "<release summary>"
+```
+
+`--detach` returns immediately instead of streaming build logs. Without it, the deploy blocks execution until the build finishes. Always include `-m` with a release summary for auditability.
+
+### Watch the build
+
+```bash
+railway up --ci -m "<release summary>"
+```
+
+`--ci` streams build logs and exits when the build completes. Use this when the user wants to see build output or when you need to triage build failures immediately.
+
+### Targeted deploy
+
+When multiple services exist, target explicitly:
+
+```bash
+railway up --service <service> --environment <environment> --detach -m "<summary>"
+```
+
+### Deploy to an unlinked project
+
+For CI or cross-project deploys where the directory isn't linked:
+
+```bash
+railway up --project <project-id> --environment <environment> --detach -m "<summary>"
+```
+
+`--project` requires `--environment`. Railway needs both to resolve context.
+
+## Manage releases
+
+### Redeploy and restart
+
+```bash
+railway redeploy --service <service> --yes       # rebuild and deploy from same source
+railway restart --service <service> --yes         # restart without rebuilding
+```
+
+Redeploy triggers a full build cycle. Restart only restarts the running container. Use restart when the code hasn't changed but the service needs a fresh process (for example, after variable changes).
+
+### Remove latest deployment
+
+```bash
+railway down --service <service> --yes
+```
+
+This removes the latest successful deployment but doesn't delete the service. To delete a service entirely, use environment config patching (see [configure.md](configure.md)).
+
+## Deployment history and logs
+
+```bash
+railway deployment list --service <service> --limit 20 --json
+railway logs --service <service> --lines 200 --json              # runtime logs
+railway logs --service <service> --build --lines 200 --json      # build logs
+railway logs --latest --lines 200 --json                         # latest deployment
+```
+
+`railway logs` streams indefinitely when no bounding flags are given. An open stream blocks execution and never returns. Always use `--lines`, `--since`, or `--until` to get a bounded fetch.
+
+## Build configuration
+
+Railway uses Railpack as the default builder. It detects language and framework from repo contents and assembles a build plan automatically.
+
+### Builder selection
+
+Three builder options, set via service config:
+
+- **RAILPACK** auto-detects language and framework, builds from source (default)
+- **NIXPACKS** is the legacy builder. DO NOT USE THIS, use RAILPACK instead.
+- **DOCKERFILE** uses a Dockerfile you provide
+
+```bash
+railway environment edit --service-config <service> build.builder RAILPACK
+railway environment edit --service-config <service> build.builder DOCKERFILE
+railway environment edit --service-config <service> build.dockerfilePath "docker/Dockerfile.prod"
+```
+
+### Build and start commands
+
+Override when auto-detection gets it wrong:
+
+```bash
+railway environment edit --service-config <service> build.buildCommand "npm run build"
+railway environment edit --service-config <service> deploy.startCommand "npm start"
+```
+
+Common reasons to override: wrong package manager detected, multiple build targets in a monorepo, framework-specific output paths.
+
+### Railpack environment variables
+
+Control Railpack behavior by setting these as service variables:
+
+| Variable | Purpose |
+|---|---|
+| `RAILPACK_NODE_VERSION` | Pin Node.js version (e.g., `20`, `22.1.0`) |
+| `RAILPACK_PYTHON_VERSION` | Pin Python version (e.g., `3.12`) |
+| `RAILPACK_GO_BIN` | Go binary name to build |
+| `RAILPACK_STATIC_FILE_ROOT` | Directory for static site output (e.g., `dist`, `build`) |
+| `RAILPACK_SPA_OUTPUT_DIR` | SPA output directory with client-side routing support |
+| `RAILPACK_PACKAGES` | Additional system packages for the build |
+| `RAILPACK_BUILD_APT_PACKAGES` | Apt packages available during build only |
+| `RAILPACK_DEPLOY_APT_PACKAGES` | Apt packages available at runtime only |
+
+For full Railpack documentation including language-specific detection, config files, and framework support: https://railpack.com/llms.txt
+
+### Static sites
+
+Railpack detects static sites from `Staticfile`, `index.html`, or `RAILPACK_STATIC_FILE_ROOT` and serves them with a built-in static file server. If the build outputs to a non-standard directory (for example, `dist/`, `build/`), set `RAILPACK_STATIC_FILE_ROOT` as a variable so Railpack knows where to find the output.
+
+## Monorepo patterns
+
+### Isolated monorepo
+
+When services don't share code, isolate each with its own root directory:
+
+```bash
+railway environment edit --service-config <service> source.rootDirectory "/packages/api"
+```
+
+Each service sees only its subdirectory. This approach is clean but breaks if services import from shared packages.
+
+### Shared monorepo
+
+When services depend on shared packages or root-level workspace config, keep the full repo context and scope via build/start commands instead:
+
+```bash
+# pnpm workspaces
+railway environment edit --service-config <service> build.buildCommand "pnpm --filter api build"
+railway environment edit --service-config <service> deploy.startCommand "pnpm --filter api start"
+
+# yarn workspaces
+railway environment edit --service-config <service> build.buildCommand "yarn workspace api build"
+railway environment edit --service-config <service> deploy.startCommand "yarn workspace api start"
+
+# bun workspaces
+railway environment edit --service-config <service> build.buildCommand "bun run --filter api build"
+railway environment edit --service-config <service> deploy.startCommand "bun run --filter api start"
+
+# turborepo (works with any package manager)
+railway environment edit --service-config <service> build.buildCommand "npx turbo run build --filter=api"
+railway environment edit --service-config <service> deploy.startCommand "npx turbo run start --filter=api"
+```
+
+Don't set a restrictive `rootDirectory` in this case. The build needs access to the workspace root.
+
+### Watch paths
+
+Prevent unrelated package changes from redeploying every service:
+
+```bash
+railway environment edit --service-config <service> build.watchPatterns '["packages/api/**","packages/shared/**"]'
+```
+
+### Common monorepo pitfalls
+
+- **Using `rootDirectory` with shared imports**: if service A imports from `packages/shared/`, setting `rootDirectory: "/packages/a"` hides the shared code. Use the shared monorepo pattern instead.
+- **Forgetting watch paths**: without watch paths, every push redeploys all services, even when only one package changed.
+- **Wrong filter target**: `pnpm --filter api` uses the `name` field in each package's `package.json`, not the directory name. Verify the package name matches.
+
+## Troubleshoot deploys
+
+- **No project/service context**: run `railway link` or pass `--project` with `--environment`
+- **Build fails before compile**: check dependency graph, lockfiles, and whether the right builder is selected
+- **Build succeeds but app crashes**: verify start command and required runtime variables
+- **Wrong files in build**: check root directory and watch patterns
+- **`railway down` treated as delete**: `down` only removes the latest deployment. For full service deletion, use `isDeleted` in config patch (see [configure.md](configure.md))
+- **Wrong Node/Python version detected**: set `RAILPACK_NODE_VERSION` or `RAILPACK_PYTHON_VERSION` as a service variable to pin the version
+- **Missing system package at runtime**: add the package to `RAILPACK_DEPLOY_APT_PACKAGES`
+
+## Validated against
+
+- Docs: [up.md](https://docs.railway.com/cli/up), [deploying.md](https://docs.railway.com/cli/deploying), [deployment.md](https://docs.railway.com/cli/deployment), [down.md](https://docs.railway.com/cli/down), [railpack.md](https://docs.railway.com/builds/railpack), [monorepo.md](https://docs.railway.com/deployments/monorepo)
+- CLI source: [up.rs](https://github.com/railwayapp/cli/blob/a8a5afe/src/commands/up.rs), [deployment.rs](https://github.com/railwayapp/cli/blob/a8a5afe/src/commands/deployment.rs), [down.rs](https://github.com/railwayapp/cli/blob/a8a5afe/src/commands/down.rs), [redeploy.rs](https://github.com/railwayapp/cli/blob/a8a5afe/src/commands/redeploy.rs), [restart.rs](https://github.com/railwayapp/cli/blob/a8a5afe/src/commands/restart.rs)