tinybird 0.0.1.dev291__py3-none-any.whl → 1.0.5__py3-none-any.whl

tinybird/tb/modules/local_logs.py

@@ -0,0 +1,209 @@
+import json
+import platform
+from typing import Optional
+
+from docker.client import DockerClient
+from docker.models.containers import Container
+
+
+def clickhouse_is_ready(container: Container) -> bool:
+    try:
+        result = container.exec_run("clickhouse 'SELECT 1 AS healthcheck'")
+        return result.output.decode("utf-8").strip() == "1"
+    except Exception:
+        return False
+
+
+def redis_is_ready(container: Container) -> bool:
+    try:
+        result = container.exec_run("redis-cli PING")
+        return result.output.decode("utf-8").strip() == "PONG"
+    except Exception:
+        return False
+
+
+def local_authentication_is_ready(container: Container) -> bool:
+    try:
+        result = container.exec_run("curl -s http://localhost:8000/tokens")
+        data = json.loads(result.output.decode("utf-8").strip())
+        token_keys = ["admin_token", "user_token", "workspace_admin_token"]
+        return all(key in data for key in token_keys)
+    except Exception:
+        return False
+
+
+def server_is_ready(container: Container) -> bool:
+    try:
+        result = container.exec_run("curl -s http://localhost:8001/health/liveness")
+        is_live = result.output.decode("utf-8").strip() == "alive"
+        if not is_live:
+            return False
+        result = container.exec_run("curl -s http://localhost:8001/health/readiness")
+        return result.output.decode("utf-8").strip() == "ready"
+    except Exception:
+        return False
+
+
+def events_is_ready(container: Container) -> bool:
+    try:
+        result = container.exec_run("curl -s http://localhost:8042/health/liveness")
+        is_live = result.output.decode("utf-8").strip() == "alive"
+        if not is_live:
+            return False
+        result = container.exec_run("curl -s http://localhost:8042/health/readiness")
+        return result.output.decode("utf-8").strip() == "ready"
+    except Exception:
+        return False
+
+
+def container_is_ready(container: Container) -> bool:
+    health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+    status = container.status
+    return health == "healthy" and status == "running"
+
+
+def container_is_starting(container: Container) -> bool:
+    status = container.status
+    health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+    return status == "restarting" or (status == "running" and health == "starting")
+
+
+def container_is_stopping(container: Container) -> bool:
+    status = container.status
+    return status == "stopping"
+
+
+def container_is_unhealthy(container: Container) -> bool:
+    health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+    return health == "unhealthy"
+
+
+def bytes_to_gb(b):
+    return round(b / (1024**3), 2)  # two decimal places (e.g., 1.75 GB)
+
+
+def get_container(client, name_or_id):
+    return client.containers.get(name_or_id)
+
+
+def get_image_arch(client, image_ref):
+    try:
+        image = client.images.get(image_ref)
+        return (image.attrs.get("Architecture") or "").lower()
+    except Exception:
+        return ""
+
+
+def is_emulated(host_arch, image_arch):
+    # Architecture equivalents - same arch with different names
+    arch_equivalents = [
+        {"x86_64", "amd64"},
+        {"aarch64", "arm64"},
+    ]
+
+    if not host_arch or not image_arch:
+        return False
+
+    if host_arch == image_arch:
+        return False
+
+    # Check if architectures are equivalent
+    return all(not (host_arch in equiv_set and image_arch in equiv_set) for equiv_set in arch_equivalents)
+
+
+def mem_usage_percent(container):
+    st = container.stats(stream=False)
+    mem = st.get("memory_stats", {}) or {}
+    limit = float(mem.get("limit") or 0.0)
+    usage = float(mem.get("usage") or 0.0)
+    stats = mem.get("stats", {}) or {}
+    inactive = float(stats.get("total_inactive_file") or stats.get("inactive_file") or 0.0)
+    used = max(usage - inactive, 0.0)
+    pct = (used / limit * 100.0) if limit > 0 else None
+    return used, limit, pct
+
+
+def container_stats(container: Container, client: DockerClient):
+    host_arch = platform.machine().lower()
+    image_arch = get_image_arch(client, container.attrs.get("Config", {}).get("Image", ""))
+    emu = is_emulated(host_arch, image_arch)
+    used_b, limit_b, pct = mem_usage_percent(container)
+    pct = round(pct, 1) if pct is not None else None
+    used_gb = bytes_to_gb(used_b)
+    limit_gb = bytes_to_gb(limit_b) if limit_b > 0 else None
+    lim_str = f"{limit_gb} GB" if limit_gb else "no-limit"
+    arch_str = f"arch={host_arch} img={image_arch or 'unknown'} emulated={str(emu).lower()}"
+    cpu_usage_pct = cpu_usage_stats(container)
+    return f"memory {used_gb}/{lim_str} cpu {cpu_usage_pct} {arch_str}"
+
+
+def cpu_usage_stats(container: Container) -> str:
+    st = container.stats(stream=False)
+    cpu = st.get("cpu_stats", {}) or {}
+    cpu_usage = cpu.get("cpu_usage", {}) or {}
+    total_usage = cpu_usage.get("total_usage", 0)
+    system_cpu_usage = cpu.get("system_cpu_usage", 0)
+    pct = (total_usage / system_cpu_usage * 100.0) if system_cpu_usage > 0 else None
+    return f"{round(pct, 1) if pct is not None else 'N/A'}%"
+
+
+def check_memory_sufficient(container: Container, client: DockerClient) -> tuple[bool, Optional[str]]:
+    """
+    Check if container has sufficient memory.
+
+    Returns:
+        tuple[bool, str | None]: (is_sufficient, warning_message)
+            - is_sufficient: True if memory is sufficient, False otherwise
+            - warning_message: None if sufficient, otherwise a warning message
+    """
+    host_arch = platform.machine().lower()
+    image_arch = get_image_arch(client, container.attrs.get("Config", {}).get("Image", ""))
+    is_emu = is_emulated(host_arch, image_arch)
+    used_b, limit_b, pct = mem_usage_percent(container)
+
+    if limit_b <= 0:
+        # No memory limit set
+        return True, None
+
+    limit_gb = bytes_to_gb(limit_b)
+    used_gb = bytes_to_gb(used_b)
+
+    # Memory thresholds
+    # For emulated containers, we need more memory and lower threshold
+    HIGH_MEMORY_THRESHOLD_EMULATED = 70.0  # 70% for emulated
+    HIGH_MEMORY_THRESHOLD_NATIVE = 85.0  # 85% for native
+    MINIMUM_MEMORY_GB_EMULATED = 6.0  # Minimum 6GB for emulated
+    MINIMUM_MEMORY_GB_NATIVE = 4.0  # Minimum 4GB for native
+
+    warnings = []
+
+    # Check memory percentage
+    if pct is not None:
+        threshold = HIGH_MEMORY_THRESHOLD_EMULATED if is_emu else HIGH_MEMORY_THRESHOLD_NATIVE
+        if pct >= threshold:
+            warnings.append(
+                f"Memory usage is at {pct:.1f}% ({used_gb}/{limit_gb:.2f} GB), "
+                f"which exceeds the recommended threshold of {threshold:.0f}%."
+            )
+
+    # Check absolute memory limit
+    min_memory = MINIMUM_MEMORY_GB_EMULATED if is_emu else MINIMUM_MEMORY_GB_NATIVE
+    if limit_gb < min_memory:
+        arch_msg = f" (running emulated {image_arch} on {host_arch})" if is_emu else ""
+        warnings.append(
+            f"Memory limit is {limit_gb:.2f} GB{arch_msg}, but at least {min_memory:.1f} GB is recommended."
+        )
+
+    if warnings:
+        warning_msg = " ".join(warnings)
+        if is_emu:
+            warning_msg += (
+                "\n"
+                f"You're running an emulated container ({image_arch} on {host_arch}), which requires more resources.\n"
+                "Consider increasing Docker's memory allocation."
+            )
+        else:
+            warning_msg += "Consider increasing Docker's memory allocation."
+        return False, warning_msg
+
+    return True, None

tinybird/tb/modules/login.py

@@ -1,9 +1,13 @@
+import platform
+import sys
 from typing import Optional
 
 import click
 
+from tinybird.tb.config import CURRENT_VERSION
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.login_common import login
+from tinybird.tb.modules.telemetry import add_telemetry_event
 
 
 @cli.command("login", help="Authenticate using the browser.")
@@ -11,12 +15,13 @@ from tinybird.tb.modules.login_common import login
     "--host",
     type=str,
     default=None,
-    help="Set custom host if it's different than https://api.europe-west2.gcp.tinybird.co. See https://www.tinybird.co/docs/api-reference/overview#regions-and-endpoints for the available list of regions.",
+    help="Set the API host to authenticate to. See https://www.tinybird.co/docs/api-reference#regions-and-endpoints for the available list of regions.",
 )
 @click.option(
     "--auth-host",
     default="https://cloud.tinybird.co",
-    help="Set the host to authenticate to. If unset, the default host will be used.",
+    help="Set the auth host to authenticate to. If unset, the default host will be used.",
+    hidden=True,
 )
 @click.option(
     "--workspace",
@@ -37,3 +42,17 @@ from tinybird.tb.modules.login_common import login
 )
 def login_cmd(host: Optional[str], auth_host: str, workspace: str, interactive: bool, method: str):
     login(host, auth_host, workspace, interactive, method)
+    # we send a telemetry event manually so we have user and workspace info available
+    add_telemetry_event(
+        "system_info",
+        platform=platform.platform(),
+        system=platform.system(),
+        arch=platform.machine(),
+        processor=platform.processor(),
+        python_runtime=platform.python_implementation(),
+        python_version=platform.python_version(),
+        is_ci=False,
+        ci_product=None,
+        cli_version=CURRENT_VERSION,
+        cli_args=sys.argv[1:] if len(sys.argv) > 1 else [],
+    )

tinybird/tb/modules/login_common.py

@@ -11,17 +11,21 @@ import threading
 import time
 import urllib.parse
 import webbrowser
+from datetime import datetime
+from pathlib import Path
 from typing import Any, Dict, Optional
 from urllib.parse import urlencode
 
 import click
 import requests
+from click import Context
 
 from tinybird.tb.config import DEFAULT_API_HOST
-from tinybird.tb.modules.common import ask_for_region_interactively, get_regions
+from tinybird.tb.modules.common import ask_for_region_interactively, get_region_from_host, get_regions
 from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.exceptions import CLILoginException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
+from tinybird.tb.modules.telemetry import is_ci_environment
 
 SERVER_MAX_WAIT_TIME = 180
 
@@ -163,14 +167,13 @@ def login(
                         "method": "code",
                     }
                     response = requests.get(f"{auth_host}/api/cli-login?{urlencode(params)}")
-
                     try:
                         if response.status_code == 200:
                             data = response.json()
                             user_token = data.get("user_token", "")
                             workspace_token = data.get("workspace_token", "")
                             if user_token and workspace_token:
-                                authenticate_with_tokens(data, host, cli_config)
+                                authenticate_with_tokens(data, cli_config)
                                 break
                     except Exception:
                         pass
@@ -216,7 +219,7 @@ def login(
             )
 
             data = response.json()
-            authenticate_with_tokens(data, host, cli_config)
+            authenticate_with_tokens(data, cli_config)
         else:
             raise Exception("Authentication failed or timed out.")
     except Exception as e:
@@ -249,9 +252,8 @@ def open_url(url: str, *, new_tab: bool = False) -> bool:
         if new_tab:
             if wb.open_new_tab(url):
                 return True
-        else:
-            if wb.open(url):
-                return True
+        elif wb.open(url):
+            return True
     except webbrowser.Error:
         pass  # keep going
 
@@ -295,9 +297,246 @@ def create_one_time_code():
     return seperator.join(parts), full_code
 
 
-def authenticate_with_tokens(data: Dict[str, Any], host: Optional[str], cli_config: CLIConfig):
+def check_current_folder_in_sessions(ctx: Context) -> None:
+    """
+    Check if the current folder is tracked in the sessions file before running a command.
+
+    If the current folder is not in sessions.txt:
+    - If no sessions exist or file doesn't exist: silently add it (first usage is fine)
+    - If other folders exist: warn the user they're running from an untracked folder
+
+    Args:
+        provider: The provider name (e.g., 'gcp', 'aws')
+        region: The region name
+        workspace_name: The workspace name
+        current_folder: The current working directory
+    """
+    try:
+        env = ctx.ensure_object(dict)["env"]
+        if env != "cloud" or ctx.invoked_subcommand == "login" or is_ci_environment():
+            return
+
+        current_folder = os.getcwd()
+        cli_config = CLIConfig.get_project_config()
+        regions = get_regions(cli_config)
+        host = cli_config.get_host()
+        if not host:
+            return
+
+        region = get_region_from_host(host, regions)
+
+        if not region:
+            return
+
+        provider = region.get("provider", "unknown")
+        region_name = region.get("name", "unknown")
+        current_folder = os.getcwd()
+        home_dir = Path.home()
+        workspace_name = cli_config.get("name", "unknown")
+        sessions_dir = home_dir / ".tinybird" / provider / region_name / workspace_name
+        sessions_file = sessions_dir / "sessions.txt"
+
+        # Normalize the current folder path
+        current_folder = os.path.abspath(current_folder)
+
+        # Read existing sessions
+        existing_sessions: dict[str, str] = {}  # folder -> timestamp
+        if sessions_file.exists():
+            try:
+                with open(sessions_file, "r") as f:
+                    for line in f:
+                        line = line.strip()
+                        if line:
+                            # Format: <folder_path>\t<timestamp>
+                            parts = line.split("\t")
+                            if len(parts) >= 2 and parts[0]:
+                                existing_sessions[parts[0]] = parts[1]
+            except Exception:
+                # If we can't read the file, just continue silently
+                return
+
+        # Check if current folder is already tracked
+        if current_folder in existing_sessions:
+            # Already tracked, update the timestamp
+            try:
+                existing_sessions[current_folder] = datetime.now().isoformat()
+                sessions_dir.mkdir(parents=True, exist_ok=True)
+                with open(sessions_file, "w") as f:
+                    f.writelines(f"{folder}\t{timestamp}\n" for folder, timestamp in existing_sessions.items())
+            except Exception:
+                # Silently fail, don't block the command
+                pass
+            return
+
+        # Current folder is not tracked
+        if not existing_sessions:
+            # No previous sessions, this is the first time - silently add it
+            try:
+                sessions_dir.mkdir(parents=True, exist_ok=True)
+                timestamp = datetime.now().isoformat()
+                with open(sessions_file, "a") as f:
+                    f.write(f"{current_folder}\t{timestamp}\n")
+            except Exception:
+                # Silently fail, don't block the command
+                pass
+        else:
+            # Other folders exist, warn the user
+            click.echo("")
+            click.echo(FeedbackManager.warning(message="Running command from an untracked folder"))
+            click.echo(FeedbackManager.gray(message="Current folder: ") + FeedbackManager.info(message=current_folder))
+            tracked_folders = ", ".join(existing_sessions.keys())
+            click.echo(
+                FeedbackManager.gray(message="Tracked folders: ") + FeedbackManager.info(message=tracked_folders)
+            )
+            confirmed = click.confirm(
+                FeedbackManager.highlight(message="» Are you sure you want to continue?"),
+                default=True,
+            )
+
+            if not confirmed:
+                raise TrackFolderCancelled("Command cancelled by user.")
+
+            # Add current folder to the tracked list
+            try:
+                timestamp = datetime.now().isoformat()
+                with open(sessions_file, "a") as f:
+                    f.write(f"{current_folder}\t{timestamp}\n")
+            except Exception:
+                # Silently fail, don't block the command
+                pass
+
+    except TrackFolderCancelled:
+        raise
+    except Exception:
+        # Don't block execution if folder check fails
+        pass
+
+
+class TrackFolderCancelled(Exception):
+    """Exception raised when the user cancels the folder tracking"""
+
+    pass
+
+
+def check_and_warn_folder_change(cli_config: CLIConfig) -> None:
+    """
+    Check if the user is logging in from a folder that hasn't been tracked before.
+
+    Reads from ~/.tinybird/<provider>/<region>/<workspace_name>/sessions.txt to track
+    folder usage history. If the current folder is not in the list of tracked folders
+    and there are existing sessions, prompts the user to confirm.
+
+    Behavior:
+        - If no sessions exist: Silently add current folder
+        - If current folder is already tracked: Update timestamp and continue
+        - If current folder is not tracked but other folders are: Show warning and ask for confirmation
+
+    Raises:
+        TrackFolderCancelled: If user declines the folder change confirmation
+    """
+    if is_ci_environment():
+        return
+
+    host = cli_config.get_host()
+    workspace_name = cli_config.get("name", None)
+    if not host or not workspace_name:
+        return
+
+    regions = get_regions(cli_config)
+    region = get_region_from_host(host, regions)
+
+    if not region:
+        return
+
+    provider = region.get("provider", "unknown")
+    region_name = region.get("name", "unknown")
+
+    current_folder = os.getcwd()
+
+    home_dir = Path.home()
+    sessions_dir = home_dir / ".tinybird" / provider / region_name / workspace_name
+    sessions_file = sessions_dir / "sessions.txt"
+
+    # Normalize the current folder path
+    current_folder = os.path.abspath(current_folder)
+
+    # Read existing sessions if the file exists
+    existing_sessions: dict[str, str] = {}  # folder -> timestamp
+    if sessions_file.exists():
+        try:
+            with open(sessions_file, "r") as f:
+                for line in f:
+                    line = line.strip()
+                    if line:
+                        # Format: <folder_path>\t<timestamp>
+                        parts = line.split("\t")
+                        if len(parts) >= 2 and parts[0]:
+                            existing_sessions[parts[0]] = parts[1]
+        except Exception as e:
+            # If we can't read the file, just continue without warning
+            click.echo(FeedbackManager.warning(message=f"Warning: Could not read sessions file: {e}"))
+
+    # If current folder is already tracked, update timestamp and return
+    if current_folder in existing_sessions:
+        try:
+            existing_sessions[current_folder] = datetime.now().isoformat()
+            sessions_dir.mkdir(parents=True, exist_ok=True)
+            with open(sessions_file, "w") as f:
+                f.writelines(f"{folder}\t{timestamp}\n" for folder, timestamp in existing_sessions.items())
+        except Exception as e:
+            click.echo(FeedbackManager.warning(message=f"Warning: Could not update sessions file: {e}"))
+        return
+
+    # If there are existing tracked folders but current folder is not tracked, warn the user
+    if existing_sessions:
+        click.echo("")
+        click.echo(
+            FeedbackManager.warning(message="Login from a different folder than previous sessions has been detected.")
+        )
+        click.echo(FeedbackManager.gray(message="Current folder: ") + FeedbackManager.info(message=current_folder))
+        tracked_folders = ", ".join(existing_sessions.keys())
+        click.echo(FeedbackManager.gray(message="Tracked folders: ") + FeedbackManager.info(message=tracked_folders))
+
+        # Ask for confirmation
+        confirmed = click.confirm(
+            FeedbackManager.highlight(message="» Are you sure you want to continue?"),
+            default=True,
+        )
+
+        if not confirmed:
+            raise TrackFolderCancelled("Login cancelled by user.")
+
+        # User accepted, show pull suggestion
+        click.echo(
+            FeedbackManager.warning(
+                message="Remember to run `tb --cloud pull` to have your latest resources available."
+            )
+        )
+
+    # Record the current session
+    try:
+        # Create the directory if it doesn't exist
+        sessions_dir.mkdir(parents=True, exist_ok=True)
+
+        # Add current folder to sessions and update timestamp
+        timestamp = datetime.now().isoformat()
+        existing_sessions[current_folder] = timestamp
+
+        # Write all sessions to file
+        with open(sessions_file, "w") as f:
+            f.writelines(f"{folder}\t{ts}\n" for folder, ts in existing_sessions.items())
+    except Exception as e:
+        # If we can't write the file, just warn but don't block the login
+        click.echo(FeedbackManager.warning(message=f"Warning: Could not update sessions file: {e}"))
+
+
+def authenticate_with_tokens(data: Dict[str, Any], cli_config: CLIConfig):
     cli_config.set_token(data.get("workspace_token", ""))
-    host = host or data.get("api_host", "")
+    host = data.get("api_host", "")
+
+    if not host:
+        raise Exception("API host not found in the authentication response")
+
     cli_config.set_token_for_host(data.get("workspace_token", ""), host)
     cli_config.set_user_token(data.get("user_token", ""))
     cli_config.set_host(host)
@@ -306,9 +545,6 @@ def authenticate_with_tokens(data: Dict[str, Any], host: Optional[str], cli_conf
         if k in ws:
             cli_config[k] = ws[k]
 
-    path = os.path.join(os.getcwd(), ".tinyb")
-    cli_config.persist_to_file(override_with_path=path)
-
     auth_info: Dict[str, Any] = cli_config.get_user_client().check_auth_login()
     if not auth_info.get("is_valid", False):
         raise Exception(FeedbackManager.error_auth_login_not_valid(host=cli_config.get_host()))
@@ -316,6 +552,12 @@ def authenticate_with_tokens(data: Dict[str, Any], host: Optional[str], cli_conf
     if not auth_info.get("is_user", False):
         raise Exception(FeedbackManager.error_auth_login_not_user(host=cli_config.get_host()))
 
+    # Check for folder change before persisting config
+    check_and_warn_folder_change(cli_config)
+
+    path = os.path.join(os.getcwd(), ".tinyb")
+    cli_config.persist_to_file(override_with_path=path)
+
     click.echo(FeedbackManager.gray(message="\nWorkspace: ") + FeedbackManager.info(message=ws["name"]))
     click.echo(FeedbackManager.gray(message="User: ") + FeedbackManager.info(message=ws["user_email"]))
     click.echo(FeedbackManager.gray(message="Host: ") + FeedbackManager.info(message=host))

tinybird/tb/modules/mock.py

@@ -1,15 +1,9 @@
-import glob
-from pathlib import Path
-
 import click
 
-from tinybird.tb.client import TinyB
+from tinybird.tb.modules.agent import run_agent
 from tinybird.tb.modules.cli import cli
-from tinybird.tb.modules.config import CLIConfig
-from tinybird.tb.modules.datafile.fixture import persist_fixture
 from tinybird.tb.modules.exceptions import CLIMockException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
-from tinybird.tb.modules.mock_common import append_mock_data, create_mock_data
 from tinybird.tb.modules.project import Project
 
 
@@ -31,60 +25,17 @@ from tinybird.tb.modules.project import Project
 )
 @click.pass_context
 def mock(ctx: click.Context, datasource: str, rows: int, prompt: str, format_: str) -> None:
-    """Generate sample data for a data source.
-
-    Args:
-        datasource: Path to the datasource file to load sample data into
-        rows: Number of events to send
-        prompt: Extra context to use for data generation
-        skip: Skip following up on the generated data
-    """
+    """Generate sample data for a data source."""
 
     try:
-        tb_client: TinyB = ctx.ensure_object(dict)["client"]
         project: Project = ctx.ensure_object(dict)["project"]
         ctx_config = ctx.ensure_object(dict)["config"]
+        prompt = f"""Generate mock data for the following datasource: {datasource} with {rows} rows and {format_} format. Extra context: {prompt}"""
         env = ctx.ensure_object(dict)["env"]
-        datasource_path = Path(datasource)
-        datasource_name = datasource
-        folder = project.folder
-        click.echo(FeedbackManager.highlight(message=f"\n» Creating fixture for {datasource_name}..."))
-        if datasource_path.suffix == ".datasource":
-            datasource_name = datasource_path.stem
-        else:
-            datasource_from_glob = glob.glob(f"{folder}/**/{datasource}.datasource")
-            if datasource_from_glob:
-                datasource_path = Path(datasource_from_glob[0])
-
-        if not datasource_path.exists():
-            raise Exception(f"Datasource '{datasource_path.stem}' not found")
-
-        datasource_content = datasource_path.read_text()
-        config = CLIConfig.get_project_config()
-        user_token = ctx_config.get("user_token")
-
-        if not user_token:
-            raise Exception("This action requires authentication. Run 'tb login' first.")
-
-        data = create_mock_data(
-            datasource_name,
-            datasource_content,
-            rows,
-            prompt,
-            config,
-            ctx_config,
-            user_token,
-            tb_client,
-            format_,
-            folder,
-        )
-
-        fixture_path = persist_fixture(datasource_name, data, folder, format=format_)
-        click.echo(FeedbackManager.info(message=f"✓ /fixtures/{datasource_name}.{format_} created"))
         if env == "cloud":
-            append_mock_data(tb_client, datasource_name, str(fixture_path))
+            prompt += "Append the fixture data to the datasource in Tinybird Cloud."
 
-        click.echo(FeedbackManager.success(message=f"✓ Sample data for {datasource_name} created with {rows} rows"))
+        run_agent(ctx_config, project, True, prompt=prompt, feature="tb_mock")
 
     except Exception as e:
         raise CLIMockException(FeedbackManager.error(message=str(e)))