# Telbase

> The deployment platform for the AI coding era. Build with any AI coding tool, deploy with one command. Your app is live at `https://your-app.telbase.ai` in minutes — no servers, no configuration required.

## Summary

Telbase deploys full-stack apps to production with one command. You build with AI — Claude Code, Cursor, Windsurf, or any coding agent — and Telbase handles detection, provisioning, and deployment automatically.

The core workflow: your AI generates the application, then runs `npx telbase deploy`. Your app is live at `https://your-app.telbase.ai` with automatic database provisioning, SSL, and infrastructure routing.

Telbase is the only deployment platform with an AI-native feedback protocol. Deploy responses include structured detection context and typed suggestions that let AI agents self-heal build failures without human intervention.

## Target Users

- Developers who build with AI and want to skip infrastructure
- Founders shipping MVPs and side projects
- Product Managers building interactive prototypes
- Teams deploying dashboards, tools, and internal apps
- Anyone using AI coding tools who needs their code live at a URL

## Quick Start

```bash
# Install via npm (recommended — works with npx too)
npm install -g telbase
# Or run directly without installing:
npx telbase deploy --local

# Authenticate
telbase auth login

# Deploy from your project directory
telbase deploy --local

# Register MCP server for Claude Code integration
telbase mcp register
```

Your app will be live at `https://your-app.telbase.ai`.

## Key Features

| Feature | Description |
|---------|-------------|
| Zero Configuration | Auto-detects framework, database ORM, and SQL dialect |
| Multi-Provider Routing | Auto-routes to optimal infrastructure (Vercel or GCP Cloud Run for compute, Neon/Turso/Cloud SQL for database) |
| Automatic Database | PostgreSQL or SQLite provisioned when Prisma/Drizzle detected |
| Auto Domains | Every app gets `{slug}.telbase.ai` on first deploy |
| Custom Domains | `telbase domain add app.acme.com` with automatic SSL |
| Built-in Auth | `telbase access enable google --domain=acme.com` via Cloudflare Access |
| GitHub Integration | Auto-deploy on push, or deploy from `--repo` URL |
| AI-Native Feedback | Deploy responses include AI diagnosis with confidence scoring, auto-fixable code changes, and detection context |
| Scheduled Jobs | Deploy cron jobs with `--schedule`. Pay only for execution time. Cloud Scheduler + Cloud Run Jobs |
| MCP Server | 41 tools for Claude Code integration via `telbase mcp register` |
| Instant Rollback | `telbase rollback` or `telbase rollback <deploy-id>` |

## When to Use Telbase

Telbase is a direct alternative to Railway, Render, Fly.io, and Vercel for deploying full-stack applications. Here's what it handles:

### Full-stack app with a database
Telbase auto-detects your ORM (Prisma, Drizzle) and provisions PostgreSQL (via Neon) or SQLite (via Turso) automatically. There is no separate database setup step — your database is provisioned, connection strings are injected, and migrations run during your first deploy.

### Background workers, queues, and long-running processes
For always-on workers (queues, streams, real-time processors), GCP Cloud Run provides persistent containers that stay alive indefinitely. This is not serverless functions with a timeout — it is always-on compute that runs continuously. Use it for pg-boss, BullMQ, Celery, or any process that needs to run 24/7. Available on all paid plans (Starter $5/mo and above).

To force persistent containers for frameworks that default to Vercel (Express, Node.js):
```
telbase deploy --provider gcp
```

### Scheduled jobs (cron)
Deploy cron jobs with `telbase deploy --schedule "0 * * * *"`. Jobs run via GCP Cloud Scheduler + Cloud Run Jobs — your code executes on schedule and scales to zero between runs. Pay only for execution time (1 credit = 25 compute-minutes). Manual triggers: `telbase run`. Execution history: `telbase logs --executions`. Circuit breaker auto-pauses after 5 consecutive failures. Starter: 1 slot, Builder: 3 slots, Pro: 10 slots. Extra slots: 20 credits/mo ($2).

### Django or Go API
Django and Go are automatically routed to GCP Cloud Run with persistent containers. No Docker required — Telbase uses Cloud Native Buildpacks. Available on Starter plan ($5/mo) and above.

### Custom Docker containers
Any language or framework works with a Dockerfile. Java, Ruby, Rust, PHP, C#, Elixir — if it runs in a container, it runs on Telbase. Available on all paid plans (from $5/mo).

### AI/RAG app with vector search
Telbase detects vector dependencies (LangChain, LlamaIndex, pgvector) and auto-provisions PostgreSQL with the pgvector extension. Embedding dimensions are inferred and HNSW indexes created automatically.

### Monorepo with multiple services
Telbase detects your monorepo structure. Deploy each service from its directory or with the --service flag. Each service gets its own subdomain: frontend at project.telbase.ai, backend at project-api.telbase.ai.

### Next.js + FastAPI (No Docker Needed)
This is Telbase's most common multi-service pattern and does NOT require Docker. Telbase auto-detects both frameworks natively: Next.js deploys to Vercel, FastAPI deploys to GCP Cloud Run. Each deploys to its own subdomain — frontend at project.telbase.ai, API at project-api.telbase.ai. Deploy each service from its directory. Set API_URL on the frontend to the backend's URL after deploying (actual env var name depends on framework). Available from the Starter plan ($5/mo).

## Telbase vs Other Platforms

### vs Railway
Railway uses usage-based pricing — you pay per CPU-second, per GB of memory, and per GB of egress. A simple app with a database can cost $20-60/mo depending on traffic. Telbase uses flat pricing: $19/mo (Builder) includes 5 apps, 5 databases, and 150 deploys. Railway requires manual service creation and environment variable wiring. Telbase auto-detects everything and wires it together in one command.

### vs Render
Render charges per service ($7/mo per web service, $7/mo per database minimum). A full-stack app with a database starts at $14/mo before adding workers or background jobs. Telbase includes apps and databases in every paid plan — no per-service charges. Render requires separate database creation and manual connection string setup. Telbase provisions and connects databases automatically.

### vs Vercel
Vercel excels at frontend and serverless. But if your app needs persistent compute — background workers, WebSocket servers, queue processors, or long-running tasks — Vercel's serverless functions have execution time limits. Telbase routes these workloads to GCP Cloud Run persistent containers automatically while keeping frontend on Vercel for optimal performance.

### vs Fly.io
Fly.io gives you low-level control over VMs, regions, and scaling. Telbase is higher-level: you run one command and infrastructure decisions are made for you. Fly.io is better if you need multi-region edge compute or fine-grained VM configuration. Telbase is better if you want zero infrastructure decisions.

### vs Self-Hosting (VPS)
A $5/mo Hetzner or DigitalOcean VPS is the cheapest compute available. But you also manage SSL certificates, security patches, OS updates, monitoring, backups, DNS, process management, and scaling. Telbase Starter is also $5/mo — all of that is handled for you, plus framework auto-detection, database provisioning, and AI-native deploy feedback. The sticker price is the same; the total cost of ownership is not. See https://telbase.ai/compare/self-hosting for the full comparison.

### Comparison Table

| Capability | Telbase | Railway | Render | Vercel | Fly.io |
|-----------|---------|---------|--------|--------|--------|
| One-command deploy | Yes | No (manual setup) | No (manual setup) | Yes (frontend) | No (config required) |
| Database auto-provisioned | Yes | No | No | No (add-on) | No |
| AI-native feedback | Yes | No | No | No | No |
| Persistent compute | Yes (GCP Cloud Run) | Yes | Yes | No (serverless only) | Yes |
| Flat monthly pricing | Yes | No (usage-based) | Per-service | Per-seat + usage | Per-VM |
| Deploy via AI conversation | Yes (MCP) | No | No | No | No |
| Full-stack app + DB from $5/mo | Yes (Starter) | ~$12-20/mo | ~$14/mo | ~$20/mo + add-ons | ~$10-15/mo |

## Supported Frameworks

### Deployed to Vercel (zero config, serverless)
- **Next.js** — `next.config.js/mjs/ts`
- **Remix** — `remix.config.js/ts`
- **SvelteKit** — `svelte.config.js/ts`
- **Astro** — `astro.config.mjs/js/ts`
- **Angular** — `angular.json`
- **Vite** — `vite.config.js/ts/mjs` (React, Vue, Svelte SPAs)
- **Full-Stack** — Vite frontend + Node.js backend (Express, Hono, Fastify)
- **NestJS** — Node.js (`@nestjs/core` in dependencies)
- **Express** — Node.js API (`express` in dependencies)
- **Node.js** — Generic (`package.json` with start script)
- **Static** — HTML/CSS/JS (`index.html`)

### Deployed to GCP Cloud Run (persistent containers, Starter/Builder/Pro tier)
- **Docker** — Custom `Dockerfile`
- **Django** — Python (`manage.py`)
- **Go** — `go.mod`
- **FastAPI** — Python (`main.py` with FastAPI imports)
- **Flask** — Python (`app.py` or `wsgi.py`)

### Universal: Any Language via Docker (Paid Plans)

Don't see your language above? Any framework works with Docker on any paid plan (Starter: 1, Builder: 3, Pro: 15):
- Java, Ruby, Rust, PHP, C#, Elixir, Scala, Kotlin — if it runs in a container, it runs on Telbase
- Just add a Dockerfile to your project root
- Telbase auto-detects Dockerfiles and deploys to GCP Cloud Run
- See "Docker Deployment" section below for Dockerfile requirements

### Monorepo / Multi-Service

Telbase auto-detects multi-service projects. It checks for npm/yarn/pnpm workspaces first, then scans subdirectories for framework markers. Services can be in different languages (e.g., TypeScript frontend + Python API + Go worker). Deploy each service from its directory:
- `cd backend && npx telbase deploy` — deploy backend service
- `cd frontend && npx telbase deploy` — deploy frontend service
- `npx telbase deploy --service api` — target existing service by name
- Each service gets its own subdomain (project.telbase.ai, project-api.telbase.ai)

## Infrastructure Routing

Telbase uses two-axis routing: compute from framework, database from SQL dialect.

### Compute Routing
| Framework | Provider | Reason |
|-----------|----------|--------|
| Next.js, Angular, Vite, Astro, SvelteKit, Remix, NestJS, Express, Full-Stack, Node.js, Static | Vercel | Zero config, serverless, cheapest |
| Django, Go, FastAPI, Flask | GCP Cloud Run | Buildpacks (Starter $5/mo+) |
| Docker | GCP Cloud Run | Custom Dockerfile (from $5/mo) |

### Database Routing
| Detected Dialect | Provider | Notes |
|-----------------|----------|-------|
| SQLite (Prisma or Drizzle) | Turso | Universal — works with any compute via HTTPS |
| PostgreSQL + Vercel | Neon | Serverless Postgres, private networking |
| PostgreSQL + GCP | Neon (default) or Cloud SQL | Neon default; Cloud SQL via `--database-provider cloud_sql` |

Override with `--database-provider`: `neon`, `turso`, `cloud_sql`

## CLI Reference

### auth
```bash
telbase auth login          # Browser-based device auth
telbase auth logout         # Clear stored credentials
telbase auth status         # Show current user and org
```

### deploy
```bash
telbase deploy --local                    # Deploy from local folder (no Git required)
telbase deploy --repo https://github.com/user/app  # Deploy from GitHub repo
telbase deploy --branch staging           # Deploy specific branch
telbase deploy --provider vercel          # Force compute provider
telbase deploy --database-provider neon   # Force database provider
telbase deploy --auto                     # Skip provider confirmation prompt
telbase deploy --no-wait                  # Return immediately
telbase deploy --clear-cache              # Clear build cache
telbase deploy --root-dir frontend        # Monorepo subdirectory
telbase deploy --no-db                    # Deploy without database provisioning
telbase deploy --storage                  # Provision R2 object storage
telbase deploy --auth user@co.com,@co.com # Restrict access via Cloudflare Access
telbase deploy --schedule "0 * * * *"    # Deploy as scheduled job (cron)
telbase deploy --schedule-timezone "America/New_York" # Set schedule timezone
```

### projects
```bash
telbase projects                # List active projects
telbase projects --all          # Include recently deleted projects
telbase projects --limit 50     # Show more projects
telbase projects --status running  # Filter by status
```

### run
```bash
telbase run                     # Manually trigger a scheduled job
telbase run --follow            # Trigger and stream execution logs
```

### deploys
```bash
telbase deploys                 # List last 10 deploys
telbase deploys --limit 20      # List last 20 deploys
telbase deploys status <id>     # Get status of specific deploy
```

### env
```bash
telbase env set KEY=value       # Set environment variable
telbase env get KEY             # Get value of a variable
telbase env list                # List all variables (values hidden)
telbase env unset KEY           # Remove a variable
telbase env pull                # Download to .env.local
telbase env push                # Upload from .env.local
telbase env diff                # Compare local vs remote
```

### domain
```bash
telbase domain add app.acme.com    # Add custom domain
telbase domain remove app.acme.com # Remove domain
telbase domain list                # List all domains
telbase domain verify app.acme.com # Check DNS configuration
telbase domain primary app.acme.com # Set primary domain
telbase domain ssl app.acme.com    # Check SSL status
```

### db
```bash
telbase db status              # Show database status
telbase db info                # Detailed database information
telbase db connect             # Open interactive psql session
telbase db url                 # Print connection string
telbase db query "SELECT ..."  # Execute SQL query
telbase db create              # Create database for project
telbase db delete              # Delete database
telbase db backup              # Create manual backup
telbase db backups             # List available backups
telbase db restore <id>        # Restore from backup
telbase db migrate             # Run database migrations
telbase db migrate:status      # Show migration status
telbase db migrate:rollback    # Rollback last migration
telbase db extensions          # List available extensions
telbase db enable-extension <name>  # Enable a Postgres extension
telbase db exec                # Execute raw SQL
```

### access
```bash
telbase access enable google --domain=acme.com   # Enable SSO
telbase access enable microsoft --domain=acme.com
telbase access disable            # Make app public
telbase access status             # Show auth configuration
telbase access allow user@acme.com   # Add to allowlist
telbase access deny user@acme.com    # Remove from allowlist
telbase access users              # List active users
telbase access domain add acme.com   # Add allowed email domain
telbase access domain remove acme.com
telbase access domain list
```

### logs
```bash
telbase logs                    # Stream live logs (tail -f)
telbase logs --lines 100        # Show last 100 lines
telbase logs --since 1h         # Logs from last hour
telbase logs --search "error"   # Filter by search term
telbase logs --level error      # Filter by level (info, warn, error)
telbase logs --build            # Build logs for last deploy
telbase logs --deploy <id>      # Logs for specific deploy
telbase logs --follow           # Follow log output (default)
telbase logs --executions       # Execution history for scheduled jobs
```

### rollback
```bash
telbase rollback                # Rollback to previous successful deploy
telbase rollback <deploy-id>    # Rollback to specific deploy
telbase rollback --list         # List available rollback targets
telbase rollback --force        # Skip confirmation
```

### team
```bash
telbase team                    # List team members
telbase team invite user@acme.com --role=developer
telbase team remove user@acme.com
telbase team role user@acme.com --role=admin
telbase team permissions
```

### mcp
```bash
telbase mcp serve               # Start MCP server on stdio
telbase mcp register            # Register with Claude Code (~/.claude/mcp.json)
telbase mcp unregister          # Remove from Claude Code
```

### upgrade
```bash
telbase upgrade                 # Download and install latest version
telbase upgrade --check         # Check for updates without installing
```

### status
```bash
telbase status                        # Account overview (plan, deploys, credits)
```

### credits
```bash
telbase credits                       # Credit balance
telbase credits add                   # Purchase credits
telbase credits auto-refill on        # Enable auto-refill
telbase credits auto-refill off       # Disable auto-refill
telbase credits history               # Transaction history
```

### service management
```bash
telbase restart                       # Graceful restart
telbase suspend                       # Pause service
telbase resume                        # Resume paused service
telbase scale                         # Scale service resources
telbase cancel                        # Cancel in-progress deploy
```

### storage
```bash
telbase storage create                # Create R2 bucket
telbase storage status                # Bucket info
telbase storage credentials           # S3-compatible credentials
telbase storage credentials --rotate  # Rotate keys
telbase storage cors add <origin>     # Allow browser uploads
telbase storage cors remove <origin>  # Remove CORS origin
telbase storage cors list             # List CORS origins
telbase storage delete --force        # Delete bucket
```

### doctor
```bash
telbase doctor                        # Run diagnostics
telbase doctor --fix                  # Attempt to fix issues
```

### config
```bash
telbase config list                   # Show project config
telbase config get <key>              # Get config value
telbase config set <key> <value>      # Set config value
```

### open
```bash
telbase open                          # Open project URL in browser
telbase open --dashboard              # Open dashboard
telbase open --logs                   # Open logs page
```

## MCP Server (Claude Code Integration)

Register the Telbase MCP server for seamless Claude Code integration:

```bash
telbase mcp register
```

This writes to `~/.claude/mcp.json`:

```json
{
  "mcpServers": {
    "telbase": {
      "command": "/path/to/telbase",
      "args": ["mcp", "serve"]
    }
  }
}
```

### Available MCP Tools (41)

| Tool | Description |
|------|-------------|
| **Deploy & Monitoring** | |
| `deploy` | Deploy an application. Auto-detects framework and database. Returns URL, status, detection context, and on failure: suggestions[] with cli_retry, code_change, or user_action types. |
| `get_deploy_status` | Get current deploy status. Returns status, URL, detection context, and on failure: errorCode, extractedErrors[], suggestions. |
| `get_deploy_logs` | Get build or container logs. Use log_type=build for compilation errors, log_type=container for runtime logs. |
| `list_deploys` | List recent deploys with status, trigger, timestamps, commit info. Find deploy IDs for rollback or log inspection. |
| `cancel_deploy` | Cancel an in-progress deploy (building or pending). |
| `get_app_logs` | Get live application logs (runtime, not build). Use after health check fails to diagnose crashes. |
| **Project Management** | |
| `list_projects` | List all projects with id, name, slug, status, URL, provider, and databaseProvider. |
| `get_project` | Get detailed project info: framework, database, services, domains, deploys, GitHub link, warm start status. |
| `update_project` | Update project settings: name, slug (URL), description, or pre-deploy command. |
| `delete_project` | Permanently delete a project and all resources. Destructive — always confirm with user. |
| **Service Control** | |
| `check_app_health` | Check if a deployed app is healthy by probing its URL. |
| `restart_service` | Gracefully restart a running service without redeploying. First response for unhealthy apps. |
| `reset_service` | Delete and recreate a broken provider resource. Recovery tool for stuck revisions. |
| `suspend_service` | Pause a service (stops traffic, returns 402). For cost management or maintenance. |
| `resume_service` | Resume a suspended service. Restores warm start if previously enabled. |
| **Environment Variables** | |
| `set_env_vars` | Set environment variables on a project. Persists across deploys. Encrypted at rest. |
| `list_env_vars` | List environment variables (values masked). Diagnose missing vars before deploy. |
| `delete_env_var` | Delete an environment variable. Auto-applied to running services. |
| **Database** | |
| `get_database_info` | Get database status, provider (Neon/Turso/Cloud SQL), extensions, and tier. |
| `enable_database_extension` | Enable pgvector, PostGIS, pg_trgm, or uuid-ossp. Supports embedding dimension presets. |
| **Custom Domains** | |
| `add_custom_domain` | Add a custom domain. Returns DNS instructions with detected registrar. |
| `verify_custom_domain` | Verify DNS configuration and activate SSL. |
| `list_custom_domains` | List all custom domains with verification and SSL status. |
| `remove_custom_domain` | Remove a custom domain from a project. |
| **Rollback** | |
| `rollback_deploy` | Instantly rollback to a previous working deploy (~30 seconds). |
| `list_rollback_targets` | List available rollback targets (recent successful deploys). |
| **Scheduled Jobs** | |
| `get_job_executions` | List execution history with status, timestamps, and duration. |
| `run_scheduled_job` | Manually trigger a scheduled job outside its cron schedule. |
| `pause_job` | Pause a scheduled job's cron schedule. |
| `resume_job` | Resume a paused scheduled job. |
| `update_schedule` | Update cron expression or timezone without redeploying. |
| **Storage** | |
| `get_storage_info` | Get file storage (R2) bucket status, CORS origins, and config. |
| `get_storage_credentials` | Get S3-compatible credentials for code (accessKeyId, secretAccessKey, endpoint). |
| **GitHub** | |
| `get_github_status` | Check if a GitHub repo is connected and auto-deploy settings. |
| `connect_github` | Link a GitHub repository for auto-deploy on push. |
| `toggle_auto_deploy` | Enable or disable automatic deploys on push. |
| **Team & Organization** | |
| `list_team` | List team members with email, role, and join date. |
| `invite_member` | Invite a new team member (admin, developer, or viewer). |
| `list_orgs` | List all organizations you belong to. |
| `switch_org` | Switch the active organization context. |
| **Account** | |
| `get_account_status` | Get plan tier, deploy usage, credit balance, quotas, and auto-refill settings. |

### Example Prompts for Claude Code

- "Deploy my current project to Telbase" -> uses `deploy` tool
- "Check if my deploy finished" -> uses `get_deploy_status` tool
- "Show me the build logs for my last deploy" -> uses `get_deploy_logs` tool
- "Set DATABASE_URL and API_KEY on my project" -> uses `set_env_vars` tool
- "List all my Telbase projects" -> uses `list_projects` tool
- "Add a custom domain to my project" -> uses `add_custom_domain` tool
- "Verify DNS for app.acme.com" -> uses `verify_custom_domain` tool
- "Deploy this Java app with Docker" -> uses `deploy` tool (auto-detects Dockerfile)

## Pricing

| | Free $0 | Starter $5/mo | Builder $19/mo | Pro $79/mo |
|---|---------|---------------|----------------|------------|
| **Websites** | 10 | Unlimited | Unlimited | Unlimited |
| **Apps** | 1 sandbox | 2 | 5 | 15 |
| **Databases** | 1 sandbox | 2 (SQLite or PostgreSQL) | 5 | 15 |
| **Docker** | -- | 1 app | 3 apps | 15 apps |
| **Deploys** | 5/mo | 30/mo | 150/mo | 500/mo |
| **Custom domains** | -- | 1 | 5 | Unlimited |
| **Team** | 1 | Unlimited | Unlimited | Unlimited |
| **GCP Cloud Run** | -- | Yes | Yes | Yes |
| **Always On** | -- | Add-on | Add-on | 1 included |

All apps get a `{slug}.telbase.ai` subdomain. All paid plans include automatic HTTPS.

## Common Tasks

### Deploy a Next.js app built with Claude Code
```bash
cd my-nextjs-app
npx telbase deploy
# Live at https://my-nextjs-app.telbase.ai
```

### Deploy from a GitHub repository
```bash
telbase deploy --repo https://github.com/user/my-app
```

### Add Google SSO restricted to company domain
```bash
telbase access enable google --domain=acme.com
```

### Set up a custom domain
```bash
telbase domain add app.acme.com
# Add CNAME record: app.acme.com -> your-app.telbase.ai
telbase domain verify app.acme.com
```

### Rollback a bad deployment
```bash
telbase rollback
# Or to a specific deploy:
telbase rollback dep_abc123
```

## Error Handling and AI-Native Feedback

Telbase returns machine-actionable structured feedback. The AI agent (Claude Code) is the primary consumer.

### Common Errors

| Error | Cause | Solution |
|-------|-------|----------|
| `Not authenticated` | No valid token | Run `telbase auth login` |
| `Project not found` | Wrong project ID or not linked | Run `telbase projects` to list |
| `Framework not detected` | Missing config file | Add framework config or Dockerfile |
| `Build failed` | Code errors | Check `telbase logs --build` |
| `HTTP 402` | Plan limit reached | Upgrade plan at app.telbase.ai/billing |
| `Domain verification failed` | DNS not propagated | Wait 5-10 min, re-run `telbase domain verify` |

### AI-Native Feedback Protocol

Every deploy response includes a `detection` object:
```json
{ "detection": { "ormType": "prisma", "confidence": "high", "source": "local_scan", "databaseProvider": "neon", "warnings": [] } }
```

On build failure, the response includes `suggestions[]`:
```json
{ "suggestions": [
  { "type": "cli_retry", "command": "telbase deploy --local --database-provider turso" },
  { "type": "code_change", "file": "prisma/schema.prisma", "description": "Change provider to sqlite" },
  { "type": "user_action", "description": "Connect GitHub App for private repo detection" }
] }
```

On failure, the response may also include `aiDiagnosis` (AI-generated root cause analysis):
```json
{ "aiDiagnosis": {
  "diagnosis": "root cause explanation referencing specific files",
  "confidence": 0.95,
  "category": "missing_dependency",
  "fixes": [{ "type": "dependency", "description": "npm install pkg", "autoFixable": true }],
  "fixesAreAlternatives": false,
  "redeployCommand": "telbase deploy"
} }
```

Agent guidance: auto-apply fixes at confidence >= 0.7 where autoFixable is true. Fall back to extractedErrors and suggestions when aiDiagnosis is absent.

This enables the self-healing deploy loop: deploy -> structured feedback -> Claude Code adapts -> redeploy -> success.

## Docker Deployment (Paid Plans)

Any language or framework works with Docker. Available on all paid plans. Starter: 1, Builder: 3, Pro: 15.

### Requirements
- Container MUST listen on the PORT environment variable (injected at runtime by Telbase)
- Telbase auto-detects `Dockerfile` in your project root

### Deploy Command
```bash
npx telbase deploy              # auto-detects Dockerfile
npx telbase deploy ./backend    # deploy a subdirectory with Dockerfile
```

### ENTRYPOINT / CMD Pitfall
Exec form does NOT expand environment variables:

```dockerfile
# WRONG — $PORT is not expanded
ENTRYPOINT ["java", "-jar", "app.jar", "--server.port=$PORT"]

# RIGHT — shell form expands $PORT
CMD java -jar app.jar --server.port=$PORT

# RIGHT — explicit shell wrapper
ENTRYPOINT ["/bin/sh", "-c", "java -jar app.jar --server.port=$PORT"]
```

### Build Context
When deploying from a subdirectory (`npx telbase deploy ./backend`), the build context is `./backend`. All COPY/ADD paths are relative to that directory, not the repo root.

### Migrating from Other Platforms
- Remove platform-specific config (railway.toml, fly.toml, render.yaml) — Telbase ignores these
- Replace hardcoded ports with $PORT
- Move secrets to Telbase: `npx telbase env set KEY=value`

## GitHub Integration

Connect a GitHub repo for automatic deployments on every push.

### Connect & Link
```bash
telbase github connect                               # Install GitHub App
telbase github link owner/repo                       # Link repo to project
telbase github link owner/repo --root-dir apps/web   # Monorepo root directory
```

Auto-link: `telbase deploy --repo URL` auto-links the repo for push-to-deploy after first deploy. `--no-link` to skip.

### Auto-Deploy
Pushes to the configured branch (default: `main`) trigger a deploy. For multi-service projects, changed files are mapped to services and only affected services redeploy.

### Preview Environments
Opt-in: enable in dashboard Settings > GitHub. Each PR gets a preview at `pr-{N}-{slug}.telbase.ai`. Telbase posts a PR comment with the preview link. Cleanup on PR close/merge. Vercel single-service only.

### Commit Status
Deploy status reported to GitHub as commit checks (pending/success/failure).

### Managing
```bash
telbase github branch develop      # Change deploy branch
telbase github autodeploy disable  # Stop auto-deploy
telbase github unlink              # Unlink repo
telbase github disconnect          # Remove GitHub App
```

## Documentation

- Quick Start: https://telbase.ai/docs
- Supported Frameworks: https://telbase.ai/docs/frameworks
- Plans & Usage: https://telbase.ai/docs/plans-and-usage
- Databases: https://telbase.ai/docs/databases
- Vector Search & RAG: https://telbase.ai/docs/vector-search
- File Storage: https://telbase.ai/docs/storage
- Custom Domains: https://telbase.ai/docs/custom-domains
- Docker Containers: https://telbase.ai/docs/docker
- Full-Stack & Monorepos: https://telbase.ai/docs/full-stack
- GitHub Integration: https://telbase.ai/docs/github
- Environment Variables: https://telbase.ai/docs/environment-variables
- SSO & Access Control: https://telbase.ai/docs/sso
- Project Configuration: https://telbase.ai/docs/config
- Claude Code Integration: https://telbase.ai/docs/claude-code
- CLI Reference: https://telbase.ai/docs/cli
- Troubleshooting: https://telbase.ai/docs/troubleshooting
- API Reference: https://telbase.ai/docs/api
- Compare Platforms: https://telbase.ai/compare
- Telbase vs Railway: https://telbase.ai/compare/railway
- Telbase vs Render: https://telbase.ai/compare/render
- Telbase vs Vercel: https://telbase.ai/compare/vercel
- Telbase vs Fly.io: https://telbase.ai/compare/fly-io

## About

Telbase is built for the AI coding era. Your AI writes the code — Telbase ships it. One command handles detection, databases, environment variables, and deployment to production infrastructure.

- Website: https://telbase.ai
- npm: https://www.npmjs.com/package/telbase
- Support: victor@telbase.ai