Skip to content

Automate browser based workflows with AI

fix: treat 'already exists' as success in quickstart DB setup (#5737)

Suchintanf203e2c37d04
diff --git a/entrypoint-skyvern.sh b/entrypoint-skyvern.sh
index b04d0e5bd..59fd1d0be 100755
--- a/entrypoint-skyvern.sh
+++ b/entrypoint-skyvern.sh
@@ -2,6 +2,38 @@
set -e
+# ---------------------------------------------------------------------------
+# Ensure the target database exists (POSTGRES_DB is only honoured on first
+# volume init — a stale postgres-data dir means the DB may be missing).
+# ---------------------------------------------------------------------------
+if [ -n "$DATABASE_STRING" ]; then
+ # Parse postgresql+psycopg://user:pass@host:port/dbname
+ db_name=$(echo "$DATABASE_STRING" | sed -n 's|.*/.*/\([^?]*\).*|\1|p')
+ db_user=$(echo "$DATABASE_STRING" | sed -n 's|.*://\([^:]*\):.*|\1|p')
+ db_host=$(echo "$DATABASE_STRING" | sed -n 's|.*@\([^:]*\):.*|\1|p')
+ db_port=$(echo "$DATABASE_STRING" | sed -n 's|.*:\([0-9]*\)/.*|\1|p')
+
+ if [ -n "$db_name" ] && [ -n "$db_user" ] && [ -n "$db_host" ]; then
+ export PGHOST="$db_host"
+ export PGPORT="${db_port:-5432}"
+ export PGUSER="$db_user"
+ # Extract password (between first : after :// and @)
+ db_pass=$(echo "$DATABASE_STRING" | sed -n 's|.*://[^:]*:\([^@]*\)@.*|\1|p')
+ if [ -n "$db_pass" ]; then
+ export PGPASSWORD="$db_pass"
+ fi
+
+ if psql -d "$db_name" -c "SELECT 1" > /dev/null 2>&1; then
+ echo "✅ Database '$db_name' exists."
+ else
+ echo "Database '$db_name' not found — creating..."
+ createdb "$db_name" && echo "✅ Database '$db_name' created." \
+ || echo "⚠️ Could not create database '$db_name' — migrations may fail."
+ fi
+ unset PGPASSWORD
+ fi
+fi
+
# Set ALLOWED_SKIP_DB_MIGRATION_VERSION env var to the DB version you want to allow (select * from alembic_version)
# If current DB matches this version, migrations will be skipped. Use at your own risk.
ALLOWED_SKIP_DB_MIGRATION_VERSION=${ALLOWED_SKIP_DB_MIGRATION_VERSION:-}
diff --git a/entrypoint-skyvernui.sh b/entrypoint-skyvernui.sh
index 600e243e9..a9850c3b8 100644
--- a/entrypoint-skyvernui.sh
+++ b/entrypoint-skyvernui.sh
@@ -8,20 +8,19 @@ VITE_WSS_BASE_URL="${VITE_WSS_BASE_URL:-ws://localhost:8000/api/v1}"
VITE_ARTIFACT_API_BASE_URL="${VITE_ARTIFACT_API_BASE_URL:-http://localhost:9090}"
# Priority for VITE_SKYVERN_API_KEY:
-# 1. Environment variable (from .env file or docker-compose environment)
-# 2. Fallback to .streamlit/secrets.toml
-if [ -n "$VITE_SKYVERN_API_KEY" ]; then
- # Trim whitespace and validate
+# 1. .streamlit/secrets.toml (generated by the backend on first run)
+# 2. Environment variable (from .env file or docker-compose environment),
+# but only if it looks like a real key (not a placeholder)
+SECRETS_KEY=$(sed -n 's/.*cred\s*=\s*"\([^"]*\)".*/\1/p' .streamlit/secrets.toml 2>/dev/null || echo "")
+if [ -n "$SECRETS_KEY" ]; then
+ VITE_SKYVERN_API_KEY="$SECRETS_KEY"
+ echo "Using VITE_SKYVERN_API_KEY from .streamlit/secrets.toml"
+elif [ -n "$VITE_SKYVERN_API_KEY" ] && [ "$VITE_SKYVERN_API_KEY" != "YOUR_API_KEY" ]; then
VITE_SKYVERN_API_KEY=$(echo "$VITE_SKYVERN_API_KEY" | xargs)
echo "Using VITE_SKYVERN_API_KEY from environment variable"
else
- # Fallback: Extract API key from secrets file
- VITE_SKYVERN_API_KEY=$(sed -n 's/.*cred\s*=\s*"\([^"]*\)".*/\1/p' .streamlit/secrets.toml 2>/dev/null || echo "")
- if [ -n "$VITE_SKYVERN_API_KEY" ]; then
- echo "Using VITE_SKYVERN_API_KEY from .streamlit/secrets.toml"
- else
- echo "WARNING: No VITE_SKYVERN_API_KEY found in environment or .streamlit/secrets.toml"
- fi
+ echo "WARNING: No VITE_SKYVERN_API_KEY found in .streamlit/secrets.toml or environment"
+ VITE_SKYVERN_API_KEY=""
fi
# Inject environment variables into pre-built JS files (replace placeholders)
diff --git a/skyvern/cli/database.py b/skyvern/cli/database.py
index a9124ccc2..4785c62c4 100644
--- a/skyvern/cli/database.py
+++ b/skyvern/cli/database.py
@@ -215,15 +215,23 @@ def setup_postgresql(no_postgres: bool = False) -> None:
console.print("✅ [green]Database user exists.[/green]")
else:
console.print("🚀 [bold green]Creating database user...[/bold green]")
- output, user_code = run_command("docker exec postgresql-container createuser -U postgres skyvern")
- if user_code != 0:
- capture_setup_event(
- "database-user-create-fail",
- success=False,
- error_type="createuser_error",
- error_message=output or "Failed to create database user",
- )
- console.print("[red]Warning: Failed to create database user.[/red]")
+ result = subprocess.run(
+ "docker exec postgresql-container createuser -U postgres skyvern",
+ shell=True,
+ capture_output=True,
+ text=True,
+ )
+ if result.returncode != 0:
+ if "already exists" in (result.stderr or ""):
+ console.print("✅ [green]Database user already exists.[/green]")
+ else:
+ capture_setup_event(
+ "database-user-create-fail",
+ success=False,
+ error_type="createuser_error",
+ error_message=result.stderr.strip() or "Failed to create database user",
+ )
+ console.print("[red]Warning: Failed to create database user.[/red]")
else:
console.print("✅ [green]Database user created.[/green]")
@@ -236,15 +244,23 @@ def setup_postgresql(no_postgres: bool = False) -> None:
console.print("✅ [green]Database exists.[/green]")
else:
console.print("🚀 [bold green]Creating database...[/bold green]")
- output, db_code = run_command("docker exec postgresql-container createdb -U postgres skyvern -O skyvern")
- if db_code != 0:
- capture_setup_event(
- "database-create-fail",
- success=False,
- error_type="createdb_error",
- error_message=output or "Failed to create database",
- )
- console.print("[red]Warning: Failed to create database.[/red]")
+ result = subprocess.run(
+ "docker exec postgresql-container createdb -U postgres skyvern -O skyvern",
+ shell=True,
+ capture_output=True,
+ text=True,
+ )
+ if result.returncode != 0:
+ if "already exists" in (result.stderr or ""):
+ console.print("✅ [green]Database already exists.[/green]")
+ else:
+ capture_setup_event(
+ "database-create-fail",
+ success=False,
+ error_type="createdb_error",
+ error_message=result.stderr.strip() or "Failed to create database",
+ )
+ console.print("[red]Warning: Failed to create database.[/red]")
else:
console.print("✅ [green]Database and user created successfully.[/green]")
diff --git a/skyvern/cli/doctor.py b/skyvern/cli/doctor.py
index 298a9e5f4..ce04ddacb 100644
--- a/skyvern/cli/doctor.py
+++ b/skyvern/cli/doctor.py
@@ -287,6 +287,238 @@ def _check_mcp_config() -> CheckResult:
)
+def _check_database() -> CheckResult:
+ from dotenv import load_dotenv
+
+ from skyvern.utils.env_paths import resolve_backend_env_path
+
+ load_dotenv(resolve_backend_env_path(), override=False)
+ db_string = os.environ.get("DATABASE_STRING", "")
+ if not db_string:
+ return CheckResult(
+ name="Database",
+ status="warn",
+ detail="DATABASE_STRING not set",
+ hint="Run `skyvern init` or set DATABASE_STRING in .env",
+ )
+
+ if db_string.startswith("sqlite"):
+ db_path = db_string.split("///")[-1] if "///" in db_string else ""
+ if db_path and Path(db_path).exists():
+ return CheckResult(name="Database", status="ok", detail=f"SQLite: {db_path}")
+ if db_path:
+ return CheckResult(
+ name="Database",
+ status="error",
+ detail=f"SQLite file not found: {db_path}",
+ hint="Run `alembic upgrade head` to initialize the database",
+ )
+ return CheckResult(name="Database", status="ok", detail="SQLite (in-memory or relative)")
+
+ # PostgreSQL — try connecting
+ try:
+ result = subprocess.run(
+ ["python", "-c", f"import sqlalchemy; e = sqlalchemy.create_engine('{db_string}'); e.connect().close()"],
+ capture_output=True,
+ text=True,
+ timeout=10,
+ )
+ if result.returncode == 0:
+ return CheckResult(name="Database", status="ok", detail=f"Connected: {_redact_password(db_string)}")
+ stderr = result.stderr.strip()
+ if "does not exist" in stderr:
+ return CheckResult(
+ name="Database",
+ status="error",
+ detail=f"Database does not exist: {_redact_password(db_string)}",
+ hint="Run `skyvern doctor --fix` to create it, or: createdb <dbname>",
+ )
+ if "Connection refused" in stderr or "could not connect" in stderr:
+ return CheckResult(
+ name="Database",
+ status="error",
+ detail=f"Cannot connect: {_redact_password(db_string)}",
+ hint="Check that PostgreSQL is running (docker ps, pg_isready)",
+ )
+ return CheckResult(
+ name="Database",
+ status="error",
+ detail=f"Connection failed: {_redact_password(db_string)}",
+ hint=stderr[:200] if stderr else "Check DATABASE_STRING in .env",
+ )
+ except subprocess.TimeoutExpired:
+ return CheckResult(
+ name="Database",
+ status="error",
+ detail=f"Connection timed out: {_redact_password(db_string)}",
+ hint="Check that PostgreSQL is reachable",
+ )
+ except FileNotFoundError:
+ return CheckResult(
+ name="Database",
+ status="warn",
+ detail="Cannot verify (python not on PATH)",
+ )
+
+
+def _check_docker() -> CheckResult:
+ if not shutil.which("docker"):
+ return CheckResult(
+ name="Docker",
+ status="warn",
+ detail="not installed",
+ hint="Install from https://docs.docker.com/get-docker/",
+ )
+
+ result = subprocess.run(["docker", "info"], capture_output=True, timeout=10)
+ if result.returncode != 0:
+ return CheckResult(
+ name="Docker",
+ status="warn",
+ detail="installed but not running",
+ hint="Start Docker Desktop",
+ )
+
+ # Check for postgres container
+ ps_result = subprocess.run(
+ ["docker", "ps", "--filter", "name=postgresql-container", "--format", "{{.Status}}"],
+ capture_output=True,
+ text=True,
+ timeout=5,
+ )
+ standalone_pg = ps_result.stdout.strip()
+
+ compose_result = subprocess.run(
+ ["docker", "compose", "ps", "--format", "json"],
+ capture_output=True,
+ text=True,
+ timeout=5,
+ )
+ compose_running = compose_result.returncode == 0 and compose_result.stdout.strip()
+
+ parts = ["running"]
+ if standalone_pg:
+ parts.append(f"postgresql-container: {standalone_pg}")
+ if compose_running:
+ parts.append("compose services active")
+ if not standalone_pg and not compose_running:
+ parts.append("no Skyvern containers detected")
+
+ return CheckResult(name="Docker", status="ok", detail=", ".join(parts))
+
+
+def _check_llm_config() -> CheckResult:
+ from dotenv import load_dotenv
+
+ from skyvern.utils.env_paths import resolve_backend_env_path
+
+ load_dotenv(resolve_backend_env_path(), override=False)
+
+ llm_key = os.environ.get("LLM_KEY", "")
+
+ providers: dict[str, dict[str, str | None]] = {
+ "OPENAI": {"enable": "ENABLE_OPENAI", "key": "OPENAI_API_KEY"},
+ "ANTHROPIC": {"enable": "ENABLE_ANTHROPIC", "key": "ANTHROPIC_API_KEY"},
+ "GEMINI": {"enable": "ENABLE_GEMINI", "key": "GEMINI_API_KEY"},
+ "AZURE": {"enable": "ENABLE_AZURE", "key": "AZURE_API_KEY"},
+ "BEDROCK": {"enable": "ENABLE_BEDROCK", "key": None},
+ "OLLAMA": {"enable": "ENABLE_OLLAMA", "key": None},
+ "OPENROUTER": {"enable": "ENABLE_OPENROUTER", "key": "OPENROUTER_API_KEY"},
+ "GROQ": {"enable": "ENABLE_GROQ", "key": "GROQ_API_KEY"},
+ }
+
+ enabled = []
+ missing_key = []
+ for name, cfg in providers.items():
+ enable_var = cfg["enable"]
+ if enable_var and os.environ.get(enable_var, "").lower() in ("true", "1", "yes"):
+ enabled.append(name)
+ api_key_var = cfg.get("key")
+ if api_key_var and not os.environ.get(api_key_var):
+ missing_key.append(f"{name} ({api_key_var})")
+
+ if not enabled:
+ return CheckResult(
+ name="LLM Provider",
+ status="error",
+ detail=f"LLM_KEY={llm_key} but no provider is enabled",
+ hint="Run `skyvern init llm` or set ENABLE_<PROVIDER>=true + API key in .env",
+ )
+
+ if missing_key:
+ return CheckResult(
+ name="LLM Provider",
+ status="error",
+ detail=f"Enabled: {', '.join(enabled)} — missing API keys: {', '.join(missing_key)}",
+ hint="Set the missing API keys in .env",
+ )
+
+ return CheckResult(
+ name="LLM Provider",
+ status="ok",
+ detail=f"LLM_KEY={llm_key}, enabled: {', '.join(enabled)}",
+ )
+
+
+def _check_api_key_consistency() -> CheckResult:
+ """Check that API keys are consistent across backend .env, frontend .env, and secrets.toml."""
+ import re
+
+ from dotenv import dotenv_values
+
+ from skyvern.utils.env_paths import resolve_backend_env_path
+
+ backend_env = resolve_backend_env_path()
+ frontend_env = Path("skyvern-frontend/.env")
+ secrets_toml = Path(".streamlit/secrets.toml")
+
+ backend_key = dotenv_values(backend_env).get("SKYVERN_API_KEY", "") if backend_env.exists() else ""
+ frontend_raw = dotenv_values(frontend_env).get("VITE_SKYVERN_API_KEY", "") if frontend_env.exists() else ""
+ frontend_key = "" if frontend_raw in ("", "YOUR_API_KEY") else frontend_raw
+
+ secrets_key = ""
+ if secrets_toml.exists():
+ m = re.search(r'cred\s*=\s*"([^"]*)"', secrets_toml.read_text())
+ if m:
+ secrets_key = m.group(1)
+
+ canonical = secrets_key or backend_key
+ if not canonical:
+ return CheckResult(
+ name="API Key Consistency",
+ status="warn",
+ detail="No API key found in backend .env or .streamlit/secrets.toml",
+ hint="Run `skyvern init` or `skyvern quickstart` to generate an API key",
+ )
+
+ mismatches: list[str] = []
+ if backend_key and backend_key != canonical:
+ mismatches.append("backend .env differs from secrets.toml")
+ if not frontend_env.exists():
+ mismatches.append("skyvern-frontend/.env missing")
+ elif not frontend_key:
+ mismatches.append("VITE_SKYVERN_API_KEY not set in frontend .env")
+ elif frontend_key != canonical:
+ mismatches.append("frontend .env differs from backend")
+
+ if mismatches:
+ return CheckResult(
+ name="API Key Consistency",
+ status="error",
+ detail="; ".join(mismatches),
+ hint="Run `skyvern doctor --fix` to sync API keys",
+ )
+
+ return CheckResult(name="API Key Consistency", status="ok", detail="Keys consistent across all config files")
+
+
+def _redact_password(db_string: str) -> str:
+ """Replace password in a database URL with ***."""
+ import re
+
+ return re.sub(r"://([^:]+):[^@]+@", r"://\1:***@", db_string)
+
+
def _check_importable(module_name: str) -> bool:
try:
return importlib.util.find_spec(module_name) is not None
@@ -340,6 +572,10 @@ def _check_dependency_groups() -> CheckResult:
_CHECKS = [
_check_python_version,
_check_config,
+ _check_database,
+ _check_docker,
+ _check_llm_config,
+ _check_api_key_consistency,
_check_playwright_browser,
_check_port_8000,
_check_api_connectivity,
@@ -354,8 +590,141 @@ _STATUS_STYLE = {
}
+def _try_fix(result: CheckResult) -> bool:
+ """Attempt to auto-fix a failing check. Returns True if fixed."""
+ if result.status == "ok":
+ return False
+
+ if result.name == "Database" and "does not exist" in result.detail:
+ return _fix_create_database()
+ if result.name == "Database" and "Cannot connect" in result.detail:
+ return _fix_start_postgres()
+ if result.name == "Playwright Browser" and result.status == "error":
+ return _fix_install_playwright()
+ if result.name == "API Key Consistency" and result.status == "error":
+ return _fix_api_key_consistency()
+ if result.name == "Docker" and "not running" in result.detail:
+ console.print(" [yellow]→ Please start Docker Desktop manually[/yellow]")
+ return False
+
+ return False
+
+
+def _fix_create_database() -> bool:
+ from dotenv import load_dotenv
+
+ from skyvern.utils.env_paths import resolve_backend_env_path
+
+ load_dotenv(resolve_backend_env_path(), override=False)
+ db_string = os.environ.get("DATABASE_STRING", "")
+ if not db_string:
+ return False
+
+ import re
+
+ m = re.match(r".*://(?P<user>[^:]+):(?P<pass>[^@]+)@(?P<host>[^:]+):(?P<port>\d+)/(?P<db>[^?]+)", db_string)
+ if not m:
+ return False
+
+ console.print(f" [cyan]Creating database '{m.group('db')}'...[/cyan]")
+ env = {
+ **os.environ,
+ "PGHOST": m.group("host"),
+ "PGPORT": m.group("port"),
+ "PGUSER": m.group("user"),
+ "PGPASSWORD": m.group("pass"),
+ }
+ result = subprocess.run(["createdb", m.group("db")], capture_output=True, text=True, env=env)
+ if result.returncode == 0 or "already exists" in (result.stderr or ""):
+ console.print(f" [green]✅ Database '{m.group('db')}' created[/green]")
+ return True
+ # Try via docker if local createdb isn't available
+ docker_result = subprocess.run(
+ ["docker", "exec", "postgresql-container", "createdb", "-U", m.group("user"), m.group("db")],
+ capture_output=True,
+ text=True,
+ )
+ if docker_result.returncode == 0 or "already exists" in (docker_result.stderr or ""):
+ console.print(f" [green]✅ Database '{m.group('db')}' created via Docker[/green]")
+ return True
+ console.print(f" [red]Failed to create database: {result.stderr or docker_result.stderr}[/red]")
+ return False
+
+
+def _fix_start_postgres() -> bool:
+ # Try starting existing docker container
+ result = subprocess.run(
+ ["docker", "start", "postgresql-container"],
+ capture_output=True,
+ text=True,
+ )
+ if result.returncode == 0:
+ console.print(" [green]✅ Started postgresql-container[/green]")
+ return True
+ # Try docker compose
+ result = subprocess.run(["docker", "compose", "up", "-d", "postgres"], capture_output=True, text=True)
+ if result.returncode == 0:
+ console.print(" [green]✅ Started postgres via Docker Compose[/green]")
+ return True
+ console.print(" [yellow]→ Could not start PostgreSQL automatically. Start it manually.[/yellow]")
+ return False
+
+
+def _fix_api_key_consistency() -> bool:
+ import re
+
+ from dotenv import dotenv_values, set_key
+
+ from skyvern.utils.env_paths import resolve_backend_env_path
+
+ backend_env = resolve_backend_env_path()
+ frontend_env = Path("skyvern-frontend/.env")
+ frontend_example = Path("skyvern-frontend/.env.example")
+ secrets_toml = Path(".streamlit/secrets.toml")
+
+ backend_key = dotenv_values(backend_env).get("SKYVERN_API_KEY", "") if backend_env.exists() else ""
+ secrets_key = ""
+ if secrets_toml.exists():
+ m = re.search(r'cred\s*=\s*"([^"]*)"', secrets_toml.read_text())
+ if m:
+ secrets_key = m.group(1)
+
+ canonical = secrets_key or backend_key
+ if not canonical:
+ console.print(" [yellow]→ No source API key found to sync from[/yellow]")
+ return False
+
+ if not frontend_env.exists() and frontend_example.exists():
+ import shutil
+
+ shutil.copy(frontend_example, frontend_env)
+ console.print(" [cyan]Created skyvern-frontend/.env from .env.example[/cyan]")
+
+ if not frontend_env.exists():
+ console.print(" [yellow]→ skyvern-frontend/.env not found and no .env.example to copy[/yellow]")
+ return False
+
+ set_key(str(frontend_env), "VITE_SKYVERN_API_KEY", canonical)
+ source = "secrets.toml" if secrets_key else "backend .env"
+ console.print(f" [green]✅ Synced VITE_SKYVERN_API_KEY in skyvern-frontend/.env (from {source})[/green]")
+ return True
+
+
+def _fix_install_playwright() -> bool:
+ console.print(" [cyan]Installing Chromium via Playwright...[/cyan]")
+ result = subprocess.run(["playwright", "install", "chromium"], capture_output=True, text=True)
+ if result.returncode == 0:
+ console.print(" [green]✅ Chromium installed[/green]")
+ return True
+ console.print(f" [red]Failed: {result.stderr[:200]}[/red]")
+ return False
+
+
@doctor_app.callback(invoke_without_command=True)
-def doctor(ctx: typer.Context) -> None:
+def doctor(
+ ctx: typer.Context,
+ fix: bool = typer.Option(False, "--fix", help="Attempt to auto-fix issues found"),
+) -> None:
"""Run diagnostic checks on the Skyvern installation."""
if ctx.invoked_subcommand is not None:
return
@@ -388,6 +757,21 @@ def doctor(ctx: typer.Context) -> None:
n_warn = sum(1 for r in results if r.status == "warn")
n_err = sum(1 for r in results if r.status == "error")
+ if fix and any(r.status in ("error", "warn") for r in results):
+ console.print("\n[bold blue]Attempting auto-fixes...[/bold blue]")
+ fixed = 0
+ for r in results:
+ if r.status in ("error", "warn"):
+ if _try_fix(r):
+ fixed += 1
+ if fixed:
+ console.print(
+ f"\n[green]Fixed {fixed} issue{'s' if fixed > 1 else ''}. Re-run `skyvern doctor` to verify.[/green]"
+ )
+ else:
+ console.print("\n[yellow]No issues could be auto-fixed. See hints above.[/yellow]")
+ return
+
if n_err > 0:
parts = []
if n_ok:
@@ -396,7 +780,9 @@ def doctor(ctx: typer.Context) -> None:
parts.append(f"[yellow]{n_warn} warning{'s' if n_warn > 1 else ''}[/yellow]")
parts.append(f"[red]{n_err} error{'s' if n_err > 1 else ''}[/red]")
summary = ", ".join(parts)
- console.print(Panel(summary, border_style="red"))
+ console.print(
+ Panel(summary + " — run [bold]skyvern doctor --fix[/bold] to attempt repairs", border_style="red")
+ )
raise typer.Exit(code=1)
elif n_warn > 0:
parts = []
diff --git a/skyvern/cli/init_command.py b/skyvern/cli/init_command.py
index 24fe0593f..8bfcf3328 100644
--- a/skyvern/cli/init_command.py
+++ b/skyvern/cli/init_command.py
@@ -10,15 +10,12 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
from rich.prompt import Confirm, Prompt
from skyvern.analytics import capture_setup_event
-from skyvern.forge.forge_app_initializer import start_forge_app
-from skyvern.utils import migrate_db
from skyvern.utils.env_paths import resolve_backend_env_path
from .browser import setup_browser_config
from .console import console
from .database import setup_postgresql
from .llm_setup import setup_llm_providers, update_or_add_env_var
-from .mcp import setup_local_organization, setup_mcp
def init_env(
@@ -50,10 +47,16 @@ def init_env(
else:
setup_postgresql(no_postgres)
console.print("📊 [bold blue]Running database migrations...[/bold blue]")
+ from skyvern.utils import migrate_db # noqa: PLC0415
+
migrate_db()
console.print("✅ [green]Database migration complete.[/green]")
console.print("🔑 [bold blue]Generating local organization API key...[/bold blue]")
+ from skyvern.forge.forge_app_initializer import start_forge_app # noqa: PLC0415
+
+ from .mcp import setup_local_organization # noqa: PLC0415
+
start_forge_app()
api_key = asyncio.run(setup_local_organization())
if api_key:
@@ -155,6 +158,8 @@ def init_env(
_mcp_browser_url = os.environ.get("BROWSER_REMOTE_DEBUGGING_URL") if run_local else None
if Confirm.ask("\nWould you like to [bold yellow]configure the MCP server[/bold yellow]?", default=True):
+ from .mcp import setup_mcp # noqa: PLC0415
+
setup_mcp(
local=run_local,
browser_type=_mcp_browser_type,
diff --git a/skyvern/cli/quickstart.py b/skyvern/cli/quickstart.py
index 52482838a..30d59b83e 100644
--- a/skyvern/cli/quickstart.py
+++ b/skyvern/cli/quickstart.py
@@ -109,6 +109,15 @@ def run_docker_compose_setup() -> None:
console.print("\n[bold blue]Step 1: Configure LLM Provider[/bold blue]")
setup_llm_providers()
+ # Ensure frontend .env exists (docker-compose.yml references it via env_file)
+ frontend_env = Path("skyvern-frontend/.env")
+ frontend_example = Path("skyvern-frontend/.env.example")
+ if not frontend_env.exists() and frontend_example.exists():
+ import shutil
+
+ shutil.copy(frontend_example, frontend_env)
+ console.print("✅ [green]Created skyvern-frontend/.env from .env.example[/green]")
+
# Run docker compose up
console.print("\n[bold blue]Step 2: Starting Docker Compose...[/bold blue]")
with Progress(
@@ -134,14 +143,27 @@ def run_docker_compose_setup() -> None:
console.print(f"[bold red]Error starting Docker Compose: {e.stderr}[/bold red]")
raise typer.Exit(1)
- console.print(
- Panel(
- "[bold green]Skyvern is now running![/bold green]\n\n"
- "Navigate to [link]http://localhost:8080[/link] to start using the UI.\n\n"
- "To stop Skyvern, run: [cyan]docker compose down[/cyan]",
- border_style="green",
+ from skyvern.cli.utils import wait_for_docker_services # noqa: PLC0415
+
+ if wait_for_docker_services():
+ console.print(
+ Panel(
+ "[bold green]Skyvern is ready![/bold green]\n\n"
+ "Navigate to [link]http://localhost:8080[/link] to start using the UI.\n\n"
+ "To stop Skyvern, run: [cyan]docker compose down[/cyan]",
+ border_style="green",
+ )
+ )
+ else:
+ console.print(
+ Panel(
+ "[yellow]Services are still starting up.[/yellow]\n\n"
+ "Navigate to [link]http://localhost:8080[/link] once ready.\n"
+ "Run [cyan]docker compose logs -f[/cyan] to monitor progress.\n\n"
+ "To stop Skyvern, run: [cyan]docker compose down[/cyan]",
+ border_style="yellow",
+ )
)
- )
# Offer to set up "Control your own browser"
use_own_browser = Confirm.ask(
diff --git a/skyvern/cli/run_commands.py b/skyvern/cli/run_commands.py
index b55a763d3..3f1bb02ba 100644
--- a/skyvern/cli/run_commands.py
+++ b/skyvern/cli/run_commands.py
@@ -247,6 +247,82 @@ def run_ui_dev(
return
+@run_app.command(name="docker")
+def run_docker() -> None:
+ """Start Skyvern via Docker Compose.
+
+ Runs 'docker compose up -d' using the docker-compose.yml in the current
+ directory (or the Skyvern package root). Use 'skyvern stop docker' or
+ 'docker compose down' to stop.
+
+ Examples:
+ skyvern run docker
+ """
+ from pathlib import Path # noqa: PLC0415
+
+ compose_file = None
+ for name in ("docker-compose.yml", "docker-compose.yaml"):
+ if Path(name).exists():
+ compose_file = name
+ break
+
+ if compose_file is None:
+ console.print(
+ Panel(
+ "[bold red]docker-compose.yml not found in current directory.[/bold red]\n"
+ "Please run this command from the Skyvern repository root, or clone it first:\n"
+ "[cyan]git clone https://github.com/skyvern-ai/skyvern.git && cd skyvern[/cyan]",
+ border_style="red",
+ )
+ )
+ raise typer.Exit(1)
+
+ result = subprocess.run(["docker", "info"], capture_output=True)
+ if result.returncode != 0:
+ console.print("[bold red]Docker is not running.[/bold red] Please start Docker Desktop and try again.")
+ raise typer.Exit(1)
+
+ # Ensure frontend .env exists (docker-compose.yml references it via env_file)
+ frontend_env = Path("skyvern-frontend/.env")
+ frontend_example = Path("skyvern-frontend/.env.example")
+ if not frontend_env.exists() and frontend_example.exists():
+ import shutil # noqa: PLC0415
+
+ shutil.copy(frontend_example, frontend_env)
+ console.print("✅ [green]Created skyvern-frontend/.env from .env.example[/green]")
+
+ console.print(Panel("[bold green]Starting Skyvern via Docker Compose...[/bold green]", border_style="green"))
+ try:
+ subprocess.run(["docker", "compose", "up", "-d"], check=True)
+ except subprocess.CalledProcessError as e:
+ console.print(f"[bold red]Docker Compose failed: {e}[/bold red]")
+ raise typer.Exit(1)
+
+ from skyvern.cli.utils import wait_for_docker_services # noqa: PLC0415
+
+ if wait_for_docker_services():
+ console.print(
+ Panel(
+ "[bold green]Skyvern is ready![/bold green]\n\n"
+ "🌐 [bold]UI:[/bold] [cyan]http://localhost:8080[/cyan]\n"
+ "🔌 [bold]API:[/bold] [cyan]http://localhost:8000[/cyan]\n\n"
+ "To stop: [cyan]skyvern stop docker[/cyan] or [cyan]docker compose down[/cyan]",
+ border_style="green",
+ )
+ )
+ else:
+ console.print(
+ Panel(
+ "[yellow]Services are still starting up.[/yellow]\n\n"
+ "🌐 [bold]UI:[/bold] [cyan]http://localhost:8080[/cyan] (check back shortly)\n"
+ "🔌 [bold]API:[/bold] [cyan]http://localhost:8000[/cyan]\n\n"
+ "Run [cyan]docker compose logs -f[/cyan] to monitor progress.\n"
+ "To stop: [cyan]skyvern stop docker[/cyan] or [cyan]docker compose down[/cyan]",
+ border_style="yellow",
+ )
+ )
+
+
@run_app.command(name="all")
def run_all() -> None:
"""Run the Skyvern API server and UI server in parallel."""
diff --git a/skyvern/cli/stop_commands.py b/skyvern/cli/stop_commands.py
index c656337ff..afa02c691 100644
--- a/skyvern/cli/stop_commands.py
+++ b/skyvern/cli/stop_commands.py
@@ -1,3 +1,4 @@
+import subprocess
from typing import List
import psutil
@@ -177,3 +178,22 @@ def stop_server(
console.print(f"[green]Skyvern API server on port {port} stopped successfully.[/green]")
else:
console.print(f"[yellow]{not_found_message}[/yellow]")
+
+
+@stop_app.command(name="docker")
+def stop_docker() -> None:
+ """Stop Skyvern Docker Compose services.
+
+ Examples:
+ skyvern stop docker
+ """
+ console.print(Panel("[bold red]Stopping Skyvern Docker Compose...[/bold red]", border_style="red"))
+ try:
+ subprocess.run(["docker", "compose", "down"], check=True)
+ console.print("[green]Skyvern Docker Compose services stopped.[/green]")
+ except FileNotFoundError:
+ console.print("[bold red]Docker is not installed.[/bold red]")
+ raise typer.Exit(1)
+ except subprocess.CalledProcessError as e:
+ console.print(f"[bold red]Failed to stop Docker Compose: {e}[/bold red]")
+ raise typer.Exit(1)
diff --git a/skyvern/cli/utils.py b/skyvern/cli/utils.py
index 16da69e33..00167b642 100644
--- a/skyvern/cli/utils.py
+++ b/skyvern/cli/utils.py
@@ -1,14 +1,45 @@
import asyncio
import logging
+import socket
import sys
+import time
import typer
+from rich.progress import Progress, SpinnerColumn, TextColumn
from skyvern.analytics import capture_setup_error, capture_setup_event
from skyvern.cli.console import console
from skyvern.utils.env_paths import resolve_backend_env_path
+def wait_for_docker_services(ui_port: int = 8080, api_port: int = 8000, timeout: int = 120) -> bool:
+ """Poll until Docker Compose services are reachable. Returns True if ready."""
+ start = time.monotonic()
+ with Progress(
+ SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True, console=console
+ ) as progress:
+ progress.add_task("[bold blue]Waiting for services to start (this may take a minute)...", total=None)
+ while time.monotonic() - start < timeout:
+ api_up = _port_open(api_port)
+ ui_up = _port_open(ui_port)
+ if api_up and ui_up:
+ return True
+ time.sleep(3)
+ return False
+
+
+def _port_open(port: int, host: str = "127.0.0.1") -> bool:
+ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ sock.settimeout(1)
+ try:
+ sock.connect((host, port))
+ return True
+ except (ConnectionRefusedError, OSError):
+ return False
+ finally:
+ sock.close()
+
+
async def start_services(server_only: bool = False) -> None:
"""Start Skyvern services in the background.