tinybird 0.0.1.dev306__py3-none-any.whl → 0.0.1.dev307__py3-none-any.whl

tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/forward/commands'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '0.0.1.dev306'
-__revision__ = 'dcef65b'
+__version__ = '0.0.1.dev307'
+__revision__ = '060369b'

tinybird/tb/cli.py

@@ -9,6 +9,7 @@ import tinybird.tb.modules.datasource
 import tinybird.tb.modules.deployment
 import tinybird.tb.modules.deprecations
 import tinybird.tb.modules.endpoint
+import tinybird.tb.modules.environment
 import tinybird.tb.modules.info
 import tinybird.tb.modules.infra
 import tinybird.tb.modules.job

tinybird/tb/client.py

@@ -711,7 +711,7 @@ class TinyB:
         return self._req(f"/{version}/user/workspaces/?with_environments=true&only_environments=true")
 
     def branches(self):
-        return self._req("/v0/environments")
+        return self._req("/v1/environments")
 
     def releases(self, workspace_id):
         return self._req(f"/v0/workspaces/{workspace_id}/releases")
@@ -740,7 +740,7 @@ class TinyB:
         }
         if ignore_datasources:
             params["ignore_datasources"] = ",".join(ignore_datasources)
-        return self._req(f"/v0/environments?{urlencode(params)}", method="POST", data=b"")
+        return self._req(f"/v1/environments?{urlencode(params)}", method="POST", data=b"")
 
     def branch_workspace_data(
         self,

tinybird/tb/modules/build.py

@@ -35,7 +35,9 @@ def build(ctx: click.Context, watch: bool) -> None:
     project: Project = ctx.ensure_object(dict)["project"]
     tb_client: TinyB = ctx.ensure_object(dict)["client"]
     config: Dict[str, Any] = ctx.ensure_object(dict)["config"]
-    if obj["env"] == "cloud":
+
+    # TODO: Explain that you can use custom environments too once they are open for everyone
+    if obj["env"] == "cloud" and not obj["environment"]:
         raise click.ClickException(FeedbackManager.error_build_only_supported_in_local())
 
     if project.has_deeper_level():
@@ -63,11 +65,18 @@ def build(ctx: click.Context, watch: bool) -> None:
 @click.option("--ui", is_flag=True, default=False, help="Connect your local project to Tinybird UI")
 @click.pass_context
 def dev(ctx: click.Context, data_origin: str, ui: bool) -> None:
+    obj: Dict[str, Any] = ctx.ensure_object(dict)
+
+    # TODO: Explain that you can use custom environments too once they are open for everyone
+    if obj["env"] == "cloud" and not obj["environment"]:
+        raise click.ClickException(FeedbackManager.error_build_only_supported_in_local())
+
     if data_origin == "cloud":
         return dev_cloud(ctx)
     project: Project = ctx.ensure_object(dict)["project"]
     tb_client: TinyB = ctx.ensure_object(dict)["client"]
     config: Dict[str, Any] = ctx.ensure_object(dict)["config"]
+
     build_status = BuildStatus()
     if ui:
         server_thread = threading.Thread(

tinybird/tb/modules/cli.py

@@ -76,6 +76,7 @@ VERSION = f"{__cli__.__version__} (rev {__cli__.__revision__})"
 )
 @click.option("--show-tokens", is_flag=True, default=False, help="Enable the output of tokens.")
 @click.option("--cloud/--local", is_flag=True, default=False, help="Run against cloud or local.")
+@click.option("--environment", help="Run against a custom environment.")
 @click.option("--staging", is_flag=True, default=False, help="Run against a staging deployment.")
 @click.option(
     "--output", type=click.Choice(["human", "json", "csv"], case_sensitive=False), default="human", help="Output format"
@@ -103,6 +104,7 @@ def cli(
     version_warning: bool,
     show_tokens: bool,
     cloud: bool,
+    environment: Optional[str],
     staging: bool,
     output: str,
     max_depth: int,
@@ -200,12 +202,21 @@ def cli(
         return
 
     ctx.ensure_object(dict)["project"] = project
-    client = create_ctx_client(ctx, config, cloud, staging, project=project, show_warnings=version_warning)
+    client = create_ctx_client(
+        ctx,
+        config,
+        cloud or bool(environment),
+        staging,
+        project=project,
+        show_warnings=version_warning,
+        environment=environment,
+    )
 
     if client:
         ctx.ensure_object(dict)["client"] = client
 
-    ctx.ensure_object(dict)["env"] = get_target_env(cloud)
+    ctx.ensure_object(dict)["env"] = get_target_env(cloud, environment)
+    ctx.ensure_object(dict)["environment"] = environment
     ctx.ensure_object(dict)["output"] = output
 
     is_prompt_mode = prompt is not None
@@ -484,7 +495,13 @@ def __hide_click_output() -> None:
 
 
 def create_ctx_client(
-    ctx: Context, config: Dict[str, Any], cloud: bool, staging: bool, project: Project, show_warnings: bool = True
+    ctx: Context,
+    config: Dict[str, Any],
+    cloud: bool,
+    staging: bool,
+    project: Project,
+    show_warnings: bool = True,
+    environment: Optional[str] = None,
 ):
     commands_without_ctx_client = [
         "auth",
@@ -506,8 +523,8 @@ def create_ctx_client(
     if not command or command in commands_without_ctx_client:
         return None
 
-    commands_always_cloud = ["infra"]
-    commands_always_local = ["build", "dev", "create"]
+    commands_always_cloud = ["infra", "environment"]
+    commands_always_local = ["dev", "create"]
     command_always_test = ["test"]
 
     if (
@@ -530,7 +547,7 @@ def create_ctx_client(
         if method and show_warnings:
             click.echo(FeedbackManager.gray(message=f"Authentication method: {method}"))
 
-        return _get_tb_client(config.get("token", ""), config["host"], staging=staging)
+        return _get_tb_client(config.get("token", ""), config["host"], staging=staging, environment=environment)
     local = command in commands_always_local
     test = command in command_always_test
     if show_warnings and not local and command not in commands_always_local and command:
@@ -538,8 +555,8 @@ def create_ctx_client(
     return get_tinybird_local_client(config, test=test, staging=staging)
 
 
-def get_target_env(cloud: bool) -> str:
-    if cloud:
+def get_target_env(cloud: bool, environment: Optional[str]) -> str:
+    if cloud or bool(environment):
         return "cloud"
     return "local"
 

tinybird/tb/modules/common.py

@@ -378,9 +378,33 @@ def getenv_bool(key: str, default: bool) -> bool:
     return v.lower() == "true" or v == "1"
 
 
-def _get_tb_client(token: str, host: str, staging: bool = False) -> TinyB:
+def _get_tb_client(token: str, host: str, staging: bool = False, environment: Optional[str] = None) -> TinyB:
     disable_ssl: bool = getenv_bool("TB_DISABLE_SSL_CHECKS", False)
-    return TinyB(token, host, version=VERSION, disable_ssl_checks=disable_ssl, send_telemetry=True, staging=staging)
+    cloud_client = TinyB(
+        token,
+        host,
+        version=VERSION,
+        disable_ssl_checks=disable_ssl,
+        send_telemetry=True,
+        staging=staging,
+    )
+
+    if not environment:
+        return cloud_client
+
+    workspaces = cloud_client.user_workspaces_and_branches(version="v1")
+    workspace = next((w for w in workspaces.get("workspaces", []) if w.get("name") == environment), None)
+    if not workspace:
+        raise CLIException(FeedbackManager.error_exception(error=f"Environment {environment} not found"))
+
+    return TinyB(
+        workspace.get("token", ""),
+        host,
+        version=VERSION,
+        disable_ssl_checks=disable_ssl,
+        send_telemetry=True,
+        staging=staging,
+    )
 
 
 def create_tb_client(ctx: Context) -> TinyB:
@@ -1165,10 +1189,26 @@ def _get_setting_value(connection, setting, sensitive_settings):
     return connection.get(setting, "")
 
 
-def switch_workspace(config: CLIConfig, workspace_name_or_id: str) -> None:
+def get_current_workspace_branches(config: CLIConfig) -> List[Dict[str, Any]]:
+    current_main_workspace: Optional[Dict[str, Any]] = get_current_main_workspace(config)
+    if not current_main_workspace:
+        raise CLIException(FeedbackManager.error_unable_to_identify_main_workspace())
+
+    client = config.get_client()
+    user_branches: List[Dict[str, Any]] = (client.user_workspace_branches("v1")).get("workspaces", [])
+    all_branches: List[Dict[str, Any]] = (client.branches()).get("environments", [])
+    branches = user_branches + [branch for branch in all_branches if branch not in user_branches]
+
+    return [branch for branch in branches if branch.get("main") == current_main_workspace["id"]]
+
+
+def switch_workspace(config: CLIConfig, workspace_name_or_id: str, only_environments: bool = False) -> None:
     try:
-        response = config.get_client().user_workspaces(version="v1")
-        workspaces = response["workspaces"]
+        if only_environments:
+            workspaces = get_current_workspace_branches(config)
+        else:
+            response = config.get_client().user_workspaces(version="v1")
+            workspaces = response["workspaces"]
 
         workspace = next(
             (
@@ -2261,3 +2301,95 @@ def update_cli() -> None:
         click.echo(FeedbackManager.success(message="✓ Tinybird CLI updated"))
     else:
         click.echo(FeedbackManager.info(message="✓ Tinybird CLI is already up-to-date"))
+
+
+def create_workspace_branch(
+    branch_name: Optional[str],
+    last_partition: bool,
+    all: bool,
+    ignore_datasources: Optional[List[str]],
+    wait: Optional[bool],
+) -> None:
+    """
+    Creates a workspace branch
+    """
+    config = CLIConfig.get_project_config()
+    _ = try_update_config_with_remote(config)
+
+    try:
+        workspace = get_current_workspace(config)
+        if not workspace:
+            raise CLIWorkspaceException(FeedbackManager.error_workspace())
+
+        if not branch_name:
+            click.echo(FeedbackManager.info_workspace_branch_create_greeting())
+            default_name = f"{workspace['name']}_{uuid.uuid4().hex[0:4]}"
+            branch_name = click.prompt("\Branch name", default=default_name, err=True, type=str)
+        assert isinstance(branch_name, str)
+
+        response = config.get_client().create_workspace_branch(
+            branch_name,
+            last_partition,
+            all,
+            ignore_datasources,
+        )
+        assert isinstance(response, dict)
+
+        is_job: bool = "job" in response
+        is_summary: bool = "partitions" in response
+
+        if not is_job and not is_summary:
+            raise CLIException(str(response))
+
+        if all and not is_job:
+            raise CLIException(str(response))
+
+        click.echo(
+            FeedbackManager.success_workspace_branch_created(workspace_name=workspace["name"], branch_name=branch_name)
+        )
+
+        job_id: Optional[str] = None
+
+        if is_job:
+            job_id = response["job"]["job_id"]
+            job_url = response["job"]["job_url"]
+            click.echo(FeedbackManager.info_data_branch_job_url(url=job_url))
+
+        if wait and is_job:
+            assert isinstance(job_id, str)
+
+            # Await the job to finish and get the result dict
+            job_response = wait_job(config.get_client(), job_id, job_url, "Environment creation")
+            if job_response is None:
+                raise CLIException(f"Empty job API response (job_id: {job_id}, job_url: {job_url})")
+            else:
+                response = job_response.get("result", {})
+                is_summary = "partitions" in response
+
+    except Exception as e:
+        raise CLIException(FeedbackManager.error_exception(error=str(e)))
+
+
+async def print_current_branch(config: CLIConfig) -> None:
+    _ = try_update_config_with_remote(config, only_if_needed=True)
+
+    response = config.get_client().user_workspaces_and_branches("v1")
+
+    columns = ["name", "id", "workspace"]
+    table = []
+
+    for workspace in response["workspaces"]:
+        if config["id"] == workspace["id"]:
+            click.echo(FeedbackManager.info_current_branch())
+            if workspace.get("is_branch"):
+                name = workspace["name"]
+                main_workspace = get_current_main_workspace(config)
+                assert isinstance(main_workspace, dict)
+                main_name = main_workspace["name"]
+            else:
+                name = MAIN_BRANCH
+                main_name = workspace["name"]
+            table.append([name, workspace["id"], main_name])
+            break
+
+    echo_safe_humanfriendly_tables_format_smart_table(table, column_names=columns)

tinybird/tb/modules/deployment_common.py

@@ -59,9 +59,14 @@ def api_post(
     params: Optional[dict] = None,
 ) -> dict:
     r = requests.post(url, headers=headers, files=files, params=params)
-    if r.status_code < 300:
-        logging.debug(json.dumps(r.json(), indent=2))
-        return r.json()
+    try:
+        if r.status_code < 300:
+            logging.debug(json.dumps(r.json(), indent=2))
+            return r.json()
+    except json.JSONDecodeError:
+        message = "Error parsing response from API"
+        click.echo(FeedbackManager.error(message=message))
+        sys_exit("deployment_error", message)
 
     # Try to parse and print the error from the response
     try:

tinybird/tb/modules/environment.py

@@ -0,0 +1,152 @@
+# This is a command file for our CLI. Please keep it clean.
+#
+# - If it makes sense and only when strictly necessary, you can create utility functions in this file.
+# - But please, **do not** interleave utility functions and command definitions.
+
+from typing import List, Optional, Tuple
+
+import click
+
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import (
+    MAIN_BRANCH,
+    create_workspace_branch,
+    echo_safe_humanfriendly_tables_format_smart_table,
+    get_current_main_workspace,
+    get_current_workspace_branches,
+    get_workspace_member_email,
+    switch_to_workspace_by_user_workspace_data,
+    try_update_config_with_remote,
+)
+from tinybird.tb.modules.config import CLIConfig
+from tinybird.tb.modules.exceptions import CLIBranchException, CLIException
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+@cli.group(hidden=True)
+def environment() -> None:
+    """Environment commands. Custom environments is an experimental feature in beta."""
+    pass
+
+
+@environment.command(name="ls")
+@click.option("--sort/--no-sort", default=False, help="Sort the table rows by name")
+def branch_ls(sort: bool) -> None:
+    """List all the environments available in the current workspace"""
+
+    config = CLIConfig.get_project_config()
+    _ = try_update_config_with_remote(config, only_if_needed=True)
+
+    client = config.get_client()
+
+    current_main_workspace = get_current_main_workspace(config)
+    assert isinstance(current_main_workspace, dict)
+
+    if current_main_workspace["id"] != config["id"]:
+        client = config.get_client(token=current_main_workspace["token"])
+
+    response = client.branches()
+
+    columns = ["name", "id", "created_at", "owner", "current"]
+
+    table: List[Tuple[str, str, str, str, bool]] = []
+
+    for branch in response["environments"]:
+        branch_owner_email = get_workspace_member_email(branch, branch["owner"])
+
+        table.append(
+            (branch["name"], branch["id"], branch["created_at"], branch_owner_email, config["id"] == branch["id"])
+        )
+
+    current_branch = [row for row in table if row[4]]
+    other_branches = [row for row in table if not row[4]]
+
+    if sort:
+        other_branches.sort(key=lambda x: x[0])
+
+    sorted_table = current_branch + other_branches
+
+    click.echo(FeedbackManager.info(message="\n** Environments:"))
+    echo_safe_humanfriendly_tables_format_smart_table(sorted_table, column_names=columns)
+
+
+@environment.command(name="create", short_help="Create a new environment in the current Workspace")
+@click.argument("environment_name", required=False)
+@click.option(
+    "--last-partition",
+    is_flag=True,
+    default=False,
+    help="Attach the last modified partition from the current workspace to the new environment",
+)
+@click.option(
+    "-i",
+    "--ignore-datasource",
+    "ignore_datasources",
+    type=str,
+    multiple=True,
+    help="Ignore specified data source partitions",
+)
+@click.option(
+    "--wait/--no-wait",
+    is_flag=True,
+    default=True,
+    help="Wait for data branch jobs to finish, showing a progress bar. Disabled by default.",
+)
+def create_environment(
+    environment_name: Optional[str], last_partition: bool, ignore_datasources: List[str], wait: bool
+) -> None:
+    create_workspace_branch(environment_name, last_partition, False, list(ignore_datasources), wait)
+
+
+@environment.command(name="rm", short_help="Removes an environment from the workspace. It can't be recovered.")
+@click.argument("branch_name_or_id")
+@click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
+def delete_environment(branch_name_or_id: str, yes: bool) -> None:
+    """Remove an environment"""
+
+    config = CLIConfig.get_project_config()
+    _ = try_update_config_with_remote(config)
+
+    client = config.get_client()
+
+    if branch_name_or_id == MAIN_BRANCH:
+        raise CLIException(FeedbackManager.error_not_allowed_in_main_branch())
+
+    try:
+        workspace_branches = get_current_workspace_branches(config)
+        workspace_to_delete = next(
+            (
+                workspace
+                for workspace in workspace_branches
+                if workspace["name"] == branch_name_or_id or workspace["id"] == branch_name_or_id
+            ),
+            None,
+        )
+    except Exception as e:
+        raise CLIBranchException(FeedbackManager.error_exception(error=str(e)))
+
+    if not workspace_to_delete:
+        raise CLIBranchException(FeedbackManager.error_branch(branch=branch_name_or_id))
+
+    if yes or click.confirm(FeedbackManager.warning_confirm_delete_branch(branch=workspace_to_delete["name"])):
+        need_to_switch_to_main = workspace_to_delete.get("main") and config["id"] == workspace_to_delete["id"]
+        # get origin workspace if deleting current branch
+        if need_to_switch_to_main:
+            try:
+                workspaces = (client.user_workspaces()).get("workspaces", [])
+                workspace_main = next(
+                    (workspace for workspace in workspaces if workspace["id"] == workspace_to_delete["main"]), None
+                )
+            except Exception:
+                workspace_main = None
+        try:
+            client.delete_branch(workspace_to_delete["id"])
+            click.echo(FeedbackManager.success_branch_deleted(branch_name=workspace_to_delete["name"]))
+        except Exception as e:
+            raise CLIBranchException(FeedbackManager.error_exception(error=str(e)))
+        else:
+            if need_to_switch_to_main:
+                if workspace_main:
+                    switch_to_workspace_by_user_workspace_data(config, workspace_main)
+                else:
+                    raise CLIException(FeedbackManager.error_switching_to_main())

tinybird/tb/modules/feedback_manager.py

@@ -841,7 +841,7 @@ STEP 3: ADD KEY TO SERVICE ACCOUNT
     )
     info_populate_job_result = info_message("** Populating job result\n {result}")
     info_populate_job_url = info_message("** Populating job url {url}")
-    info_data_branch_job_url = info_message("** Branch job url {url}")
+    info_data_branch_job_url = info_message("** Environment job url {url}")
     info_regression_tests_branch_job_url = info_message("** Branch regression tests job url {url}")
     info_merge_branch_job_url = info_message("** Merge Branch deployment job url {url}")
     info_copy_from_main_job_url = info_message("** Copy from 'main' Workspace to '{datasource_name}' job url {url}")
@@ -1161,7 +1161,7 @@ STEP 3: ADD KEY TO SERVICE ACCOUNT
         "** Workspace '{workspace_name}' has been created in Organization '{organization_name}' (id: '{organization_id}')"
     )
     success_workspace_branch_created = success_message(
-        "** Branch '{branch_name}' from '{workspace_name}' has been created"
+        "** Environment '{branch_name}' from '{workspace_name}' has been created"
     )
     success_workspace_data_branch = success_message(
         "** Partitions from 'main' Workspace have been attached to the Branch"
@@ -1174,7 +1174,7 @@ STEP 3: ADD KEY TO SERVICE ACCOUNT
         "Deploying your new '{workspace_name}' workspace, using the '{template}' template:"
     )
     success_workspace_deleted = success_message("** Workspace '{workspace_name}' deleted")
-    success_branch_deleted = success_message("** Branch '{branch_name}' deleted")
+    success_branch_deleted = success_message("** Environment '{branch_name}' deleted")
     success_workspace_user_added = success_message("** User {user} added to workspace '{workspace_name}'")
     success_workspace_users_added = success_message("** Users added to workspace '{workspace_name}'")
     success_workspace_user_removed = success_message("** User {user} removed from workspace '{workspace_name}'")

tinybird/tb/modules/local.py

@@ -141,8 +141,19 @@ def remove() -> None:
     envvar="TB_LOCAL_WORKSPACE_TOKEN",
     help="Workspace token to use for the Tinybird Local container.",
 )
+@click.option(
+    "--watch",
+    default=False,
+    is_flag=True,
+    help="Watch container in the console. Press Ctrl+C to stop the container.",
+)
 def start(
-    use_aws_creds: bool, volumes_path: str, skip_new_version: bool, user_token: str, workspace_token: str
+    use_aws_creds: bool,
+    volumes_path: str,
+    skip_new_version: bool,
+    user_token: str,
+    workspace_token: str,
+    watch: bool,
 ) -> None:
     """Start Tinybird Local"""
     if volumes_path is not None:
@@ -152,8 +163,11 @@ def start(
 
     click.echo(FeedbackManager.highlight(message="» Starting Tinybird Local..."))
     docker_client = get_docker_client()
-    start_tinybird_local(docker_client, use_aws_creds, volumes_path, skip_new_version, user_token, workspace_token)
-    click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
+    start_tinybird_local(
+        docker_client, use_aws_creds, volumes_path, skip_new_version, user_token, workspace_token, watch=watch
+    )
+    if not watch:
+        click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
 
 
 @local.command()

tinybird/tb/modules/local_common.py

@@ -4,6 +4,7 @@ import logging
 import os
 import re
 import subprocess
+import threading
 import time
 import uuid
 from typing import Any, Dict, Optional
@@ -35,11 +36,18 @@ def get_tinybird_local_client(
     config_obj: Dict[str, Any], test: bool = False, staging: bool = False, silent: bool = False
 ) -> TinyB:
     """Get a Tinybird client connected to the local environment."""
-
-    config = get_tinybird_local_config(config_obj, test=test, silent=silent)
-    client = config.get_client(host=TB_LOCAL_ADDRESS, staging=staging)
-    load_secrets(config_obj.get("path", ""), client)
-    return client
+    try:
+        config = get_tinybird_local_config(config_obj, test=test, silent=silent)
+        client = config.get_client(host=TB_LOCAL_ADDRESS, staging=staging)
+        load_secrets(config_obj.get("path", ""), client)
+        return client
+    # if some of the API calls to tinybird local fail due to a JSONDecodeError, it means that container is running but it's unhealthy
+    except json.JSONDecodeError:
+        raise CLILocalException(
+            message=FeedbackManager.error(
+                message="Tinybird Local is running but it's unhealthy. Please check if it's running and try again. If the problem persists, please run `tb local restart` and try again."
+            )
+        )
 
 
 def get_tinybird_local_config(config_obj: Dict[str, Any], test: bool = False, silent: bool = False) -> CLIConfig:
@@ -140,6 +148,7 @@ def get_local_tokens() -> Dict[str, str]:
                 },
             )
 
+            # TODO: If docker errors persist, explain that you can use custom environments too once they are open for everyone
             if container and container.status == "running":
                 if container.health == "healthy":
                     raise CLILocalException(
@@ -237,6 +246,7 @@ def start_tinybird_local(
     skip_new_version: bool = True,
     user_token: Optional[str] = None,
     workspace_token: Optional[str] = None,
+    watch: bool = False,
 ) -> None:
     """Start the Tinybird container."""
     pull_show_prompt = False
@@ -299,6 +309,190 @@ def start_tinybird_local(
         )
 
     click.echo(FeedbackManager.info(message="* Waiting for Tinybird Local to be ready..."))
+
+    if watch:
+        # Stream logs in a separate thread while monitoring container health
+        container_ready = threading.Event()
+        stop_requested = threading.Event()
+        health_check_error = {"message": ""}  # Mutable dict to store error message
+
+        def check_endpoints_health() -> None:
+            """Continuously check /tokens and /v0/health endpoints"""
+            # Wait for container to be ready before starting health checks
+            container_ready.wait()
+
+            # Give container a moment to fully start up
+            time.sleep(2)
+
+            check_interval = 10  # Check every 10 seconds
+
+            while not stop_requested.is_set():
+                try:
+                    # Check /tokens endpoint
+                    tokens_response = requests.get(f"{TB_LOCAL_ADDRESS}/tokens", timeout=5)
+                    if tokens_response.status_code != 200:
+                        health_check_error["message"] = (
+                            f"/tokens endpoint returned status {tokens_response.status_code}. "
+                            "Tinybird Local may be unhealthy."
+                        )
+                        stop_requested.set()
+                        break
+
+                    # Check /v0/health endpoint
+                    health_response = requests.get(f"{TB_LOCAL_ADDRESS}/v0/health", timeout=5)
+                    if health_response.status_code != 200:
+                        health_check_error["message"] = (
+                            f"/v0/health endpoint returned status {health_response.status_code}. "
+                            "Tinybird Local may be unhealthy."
+                        )
+                        stop_requested.set()
+                        break
+
+                    # Verify tokens response has expected structure
+                    try:
+                        tokens_data = tokens_response.json()
+                        if not all(
+                            key in tokens_data for key in ["user_token", "admin_token", "workspace_admin_token"]
+                        ):
+                            health_check_error["message"] = (
+                                "/tokens endpoint returned unexpected data. Tinybird Local may be unhealthy."
+                            )
+                            stop_requested.set()
+                            break
+                    except json.JSONDecodeError:
+                        health_check_error["message"] = (
+                            "/tokens endpoint returned invalid JSON. Tinybird Local may be unhealthy."
+                        )
+                        stop_requested.set()
+                        break
+
+                except Exception as e:
+                    # Check if it's a connection error
+                    error_str = str(e)
+                    if "connect" in error_str.lower() or "timeout" in error_str.lower():
+                        health_check_error["message"] = f"Failed to connect to Tinybird Local: {error_str}"
+                    else:
+                        health_check_error["message"] = f"Health check failed: {error_str}"
+                    stop_requested.set()
+                    break
+
+                # Wait before next check
+                for _ in range(check_interval):
+                    if stop_requested.is_set():
+                        break
+                    time.sleep(1)
+
+        def stream_logs_with_health_check() -> None:
+            """Stream logs and monitor container health in parallel"""
+            log_names = {
+                "/var/log/tinybird-local-setup.log": "SETUP",
+                "/var/log/tinybird-local-server.log": "SERVER",
+            }
+
+            # Wait briefly for log files to be created
+            retry_count = 0
+            max_retries = 3
+            exec_result = None
+
+            while retry_count < max_retries and not stop_requested.is_set():
+                try:
+                    # Try to tail the log files (only new logs, not historical)
+                    # Use -F to follow by name and retry if files don't exist yet
+                    cmd = ["tail", "-n", "0", "-F", *log_names.keys()]
+                    exec_result = container.exec_run(cmd=cmd, stream=True, tty=False, stdout=True, stderr=True)
+                    break  # Success, exit retry loop
+                except Exception:
+                    # Log file might not exist yet, wait and retry
+                    retry_count += 1
+                    if retry_count < max_retries:
+                        time.sleep(2)
+
+            # If we couldn't start tailing, fall back to container logs
+            if not exec_result and not stop_requested.is_set():
+                try:
+                    for line in container.logs(stream=True, follow=True):
+                        if stop_requested.is_set():
+                            break
+                        click.echo(line.decode("utf-8").rstrip())
+                    return
+                except Exception:
+                    return  # Silently ignore errors in log streaming
+
+            # Stream logs continuously
+            if exec_result:
+                try:
+                    for line in exec_result.output:
+                        if stop_requested.is_set():
+                            break
+
+                        decoded_line = line.decode("utf-8").rstrip()
+
+                        # Skip tail error messages about files not existing yet
+                        if "tail:" in decoded_line and (
+                            "cannot open" in decoded_line or "no files remaining" in decoded_line
+                        ):
+                            continue
+
+                        # Replace file path headers with friendly names
+                        for file_path, friendly_name in log_names.items():
+                            log_header = f"==> {file_path} <=="
+                            if log_header in decoded_line:
+                                decoded_line = decoded_line.replace(log_header, f"==> {friendly_name} <==")
+
+                        # Print "ready" message when container becomes healthy
+                        if container_ready.is_set() and not hasattr(stream_logs_with_health_check, "ready_printed"):
+                            click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
+                            click.echo(
+                                FeedbackManager.highlight(message="» Watching Tinybird Local... (Press Ctrl+C to stop)")
+                            )
+                            stream_logs_with_health_check.ready_printed = True  # type: ignore
+
+                        click.echo(decoded_line)
+                except Exception:
+                    pass  # Silently ignore errors when stream is interrupted
+
+        log_thread = threading.Thread(target=stream_logs_with_health_check, daemon=True)
+        log_thread.start()
+
+        health_check_thread = threading.Thread(target=check_endpoints_health, daemon=True)
+        health_check_thread.start()
+
+        # Monitor container health in main thread
+        try:
+            while True:
+                container.reload()  # Refresh container attributes
+                health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+                if health == "healthy":
+                    container_ready.set()
+                    # Keep monitoring and streaming logs until Ctrl+C or health check failure
+                    while True:
+                        # Check if health check detected an error
+                        if stop_requested.is_set() and health_check_error["message"]:
+                            time.sleep(0.5)  # Give log thread time to finish printing
+                            click.echo(
+                                FeedbackManager.error(
+                                    message=f"\n✗ {health_check_error['message']}\n"
+                                    "Please run `tb local restart` to restart the container."
+                                )
+                            )
+                            return
+                        time.sleep(1)
+                if health == "unhealthy":
+                    stop_requested.set()
+                    raise CLILocalException(
+                        FeedbackManager.error(
+                            message="Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds."
+                        )
+                    )
+                time.sleep(5)
+        except KeyboardInterrupt:
+            stop_requested.set()
+            click.echo(FeedbackManager.highlight(message="» Stopping Tinybird Local..."))
+            container.stop()
+            click.echo(FeedbackManager.success(message="✓ Tinybird Local stopped."))
+            return
+
+    # Non-watch mode: just wait for container to be healthy
     while True:
         container.reload()  # Refresh container attributes
         health = container.attrs.get("State", {}).get("Health", {}).get("Status")
@@ -310,7 +504,6 @@ def start_tinybird_local(
                     message="Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds."
                 )
             )
-
         time.sleep(5)
 
     # Remove tinybird-local dangling images to avoid running out of disk space

{tinybird-0.0.1.dev306.dist-info → tinybird-0.0.1.dev307.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 0.0.1.dev306
+Version: 0.0.1.dev307
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/forward/commands
 Author: Tinybird

{tinybird-0.0.1.dev306.dist-info → tinybird-0.0.1.dev307.dist-info}/RECORD

@@ -18,35 +18,36 @@ tinybird/datafile/exceptions.py,sha256=8rw2umdZjtby85QbuRKFO5ETz_eRHwUY5l7eHsy1w
 tinybird/datafile/parse_connection.py,sha256=tRyn2Rpr1TeWet5BXmMoQgaotbGdYep1qiTak_OqC5E,1825
 tinybird/datafile/parse_datasource.py,sha256=ssW8QeFSgglVFi3sDZj_HgkJiTJ2069v2JgqnH3CkDE,1825
 tinybird/datafile/parse_pipe.py,sha256=8e9LMecSQVWHC4AXf8cdxoQ1nxUR4fTObYxTctO_EXQ,3816
-tinybird/tb/__cli__.py,sha256=kZpdvL-dPYWUC1OIxl9P1uxd9h4rCOkGdikrpyt0_Us,247
+tinybird/tb/__cli__.py,sha256=sGbfRkjI4JkVGzo0JQPjoiJ4aJczl7ueJiW4NshluI4,247
 tinybird/tb/check_pypi.py,sha256=Gp0HkHHDFMSDL6nxKlOY51z7z1Uv-2LRexNTZSHHGmM,552
-tinybird/tb/cli.py,sha256=FdDFEIayjmsZEVsVSSvRiVYn_FHOVg_zWQzchnzfWho,1008
-tinybird/tb/client.py,sha256=Z27O6kXbQ1ZVi_K6qzdUJoS877nt7rqQDRckOycjNmI,53544
+tinybird/tb/cli.py,sha256=Os4uApzYYVPXcYFdaReQs9E12q9DOuYOUVFoOgt7i7U,1047
+tinybird/tb/client.py,sha256=VYbllzIsmBS4b56Ix-vsyLbhpbe7MVRxR1sIo6xU2qA,53544
 tinybird/tb/config.py,sha256=XIKju3xxpo40oQ48zDtSv0vgUrBZBHSmHJi4SHksjXE,5447
-tinybird/tb/modules/build.py,sha256=q3f_CM-_yt7R24VCmQqe4yat1aPdLqmP_hW5WoqdxBg,7907
+tinybird/tb/modules/build.py,sha256=gnZoqxEzFDc8OKVzmKIaesy3tat0lbJ3E8JKmsKTutw,8321
 tinybird/tb/modules/build_common.py,sha256=zHqnzEdJvEIlzDGEL5HqcUXInuKLqYG6hPCdB6f6PMA,20064
 tinybird/tb/modules/cicd.py,sha256=0KLKccha9IP749QvlXBmzdWv1On3mFwMY4DUcJlBxiE,7326
-tinybird/tb/modules/cli.py,sha256=pjl7537sWw0o8IqnDFqdp9RPvgARnJN0cX2vMPHn9Bg,20816
-tinybird/tb/modules/common.py,sha256=UkrlPni5jh43w18FOWx3icNbjpAWbB-bgXDWOQPGh3Y,83559
+tinybird/tb/modules/cli.py,sha256=YsnFZT3WbeFX-zhlB9t10czHKzRJBoutzLZZe1OqUCw,21240
+tinybird/tb/modules/common.py,sha256=vSfyJCdmoUvO1B_JmODqKeMYQy4VXOYrFhBue758VMw,88275
 tinybird/tb/modules/config.py,sha256=gK7rgaWTDd4ZKCrNEg_Uemr26EQjqWt6TjyQKujxOws,11462
 tinybird/tb/modules/connection.py,sha256=axp8Fny1_4PSLJGN4UF6WygyRbQtM3Lbt6thxHKTxzw,17790
 tinybird/tb/modules/copy.py,sha256=dPZkcIDvxjJrlQUIvToO0vsEEEs4EYumbNV77-BzNoU,4404
 tinybird/tb/modules/create.py,sha256=j0WvO6LxuGW1ZOYVuvR1FxFls2oMmKePYNTRJMSXfuU,20135
 tinybird/tb/modules/datasource.py,sha256=O-w4qwhAIitD_SLVdxkpknckliRp_xMswdB8n8Ohxo0,42335
 tinybird/tb/modules/deployment.py,sha256=v0layOmG0IMnuXc3RT39mpGfa5M8yPlrL9F089fJFCo,15964
-tinybird/tb/modules/deployment_common.py,sha256=5fAXTaK5HhmZts3fkqJ1W9d57I9fD_q3z9uyySePtJI,20453
+tinybird/tb/modules/deployment_common.py,sha256=68qoCoOQFqRFyvxWwYmKiuVb37z7txBhEvzSOJGUHMc,20664
 tinybird/tb/modules/deprecations.py,sha256=rrszC1f_JJeJ8mUxGoCxckQTJFBCR8wREf4XXXN-PRc,4507
 tinybird/tb/modules/dev_server.py,sha256=57FCKuWpErwYUYgHspYDkLWEm9F4pbvVOtMrFXX1fVU,10129
 tinybird/tb/modules/endpoint.py,sha256=ksRj6mfDb9Xv63PhTkV_uKSosgysHElqagg3RTt21Do,11958
+tinybird/tb/modules/environment.py,sha256=z99321d_imk3eLJx9JNZIWMVcaRPUNixUV8pom4OL5o,5724
 tinybird/tb/modules/exceptions.py,sha256=_1BHy0OixEkeF0fOCu1_1Pj8pJS4BNfUyucqCViJGTw,5958
-tinybird/tb/modules/feedback_manager.py,sha256=duigLI2UIeMzP5IOa7XUty23NRvNssm2ZAKicuun3Pg,78130
+tinybird/tb/modules/feedback_manager.py,sha256=mSlsC1dN0Val0tDcUP8EXcnFVNXnyjBdmDhKVSc2qR0,78145
 tinybird/tb/modules/info.py,sha256=UKlazKWSE3bzEtggTwyDhmkh7WRrWURuBraR36ClbmQ,7177
 tinybird/tb/modules/infra.py,sha256=J9Noe9aZo5Y9ZKAhqh9jnv8azfivXLLHQ2a9TeMWN9s,32673
 tinybird/tb/modules/job.py,sha256=wBsnu8UPTOha2rkLvucgmw4xYv73ubmui3eeSIF68ZM,3107
 tinybird/tb/modules/llm.py,sha256=fPBBCmM3KlCksLlgJkg4joDn6y3H5QjDzE-Pm4YNf7E,1782
 tinybird/tb/modules/llm_utils.py,sha256=nS9r4FAElJw8yXtmdYrx-rtI2zXR8qXfi1QqUDCfxvg,3469
-tinybird/tb/modules/local.py,sha256=aGqBtRyr9Ks0BWUFEveez2g_-4h6YjLO6Rt49b1i-yE,8384
-tinybird/tb/modules/local_common.py,sha256=UUDGS5M3C261NUtZO_LrmfEYfUH1sjn1kjjBMlY32xI,18801
+tinybird/tb/modules/local.py,sha256=Fw5yTJBzGc_d4nYKCzjxEfDZogc4P-2nQJf5_rNRwuA,8616
+tinybird/tb/modules/local_common.py,sha256=3WLYEm8bUik6Z2YFiWmzfhOpuChb-Iyy0cnYQoCnRIA,28302
 tinybird/tb/modules/login.py,sha256=q2fc0dy5brwofQSNQppipS1aDcyrxHvVjZZbzIA3b4g,1916
 tinybird/tb/modules/login_common.py,sha256=u1Eh1u6L7V3x8qmxVO-LnWDELHWAnXm3bvb7BNjVXF8,11990
 tinybird/tb/modules/logout.py,sha256=sniI4JNxpTrVeRCp0oGJuQ3yRerG4hH5uz6oBmjv724,1009
@@ -121,8 +122,8 @@ tinybird/tb_cli_modules/config.py,sha256=IsgdtFRnUrkY8-Zo32lmk6O7u3bHie1QCxLwgp4
 tinybird/tb_cli_modules/exceptions.py,sha256=pmucP4kTF4irIt7dXiG-FcnI-o3mvDusPmch1L8RCWk,3367
 tinybird/tb_cli_modules/regions.py,sha256=QjsL5H6Kg-qr0aYVLrvb1STeJ5Sx_sjvbOYO0LrEGMk,166
 tinybird/tb_cli_modules/telemetry.py,sha256=Hh2Io8ZPROSunbOLuMvuIFU4TqwWPmQTqal4WS09K1A,10449
-tinybird-0.0.1.dev306.dist-info/METADATA,sha256=7k-rYFZmsHITYe0TZqERa8JdoC4ysCstCKvFEqxiGvA,1881
-tinybird-0.0.1.dev306.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-tinybird-0.0.1.dev306.dist-info/entry_points.txt,sha256=LwdHU6TfKx4Qs7BqqtaczEZbImgU7Abe9Lp920zb_fo,43
-tinybird-0.0.1.dev306.dist-info/top_level.txt,sha256=VqqqEmkAy7UNaD8-V51FCoMMWXjLUlR0IstvK7tJYVY,54
-tinybird-0.0.1.dev306.dist-info/RECORD,,
+tinybird-0.0.1.dev307.dist-info/METADATA,sha256=F1RA-wrl0jqMAo128B0tMdVBrCTW5zEC1EulkwKSyHo,1881
+tinybird-0.0.1.dev307.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+tinybird-0.0.1.dev307.dist-info/entry_points.txt,sha256=LwdHU6TfKx4Qs7BqqtaczEZbImgU7Abe9Lp920zb_fo,43
+tinybird-0.0.1.dev307.dist-info/top_level.txt,sha256=VqqqEmkAy7UNaD8-V51FCoMMWXjLUlR0IstvK7tJYVY,54
+tinybird-0.0.1.dev307.dist-info/RECORD,,