datn-cli 0.2.2__py3-none-any.whl

datn_cli/__init__.py

@@ -0,0 +1,3 @@
+"""datn-cli — one-command distribution wrapper hiding docker compose."""
+
+__version__ = "0.2.2"

datn_cli/__main__.py

@@ -0,0 +1,264 @@
+"""datn — CLI che giấu docker compose cho hệ multi-agent assistant."""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import webbrowser
+
+import typer
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+
+from . import __version__
+from . import compose as cm
+from . import config as cfg
+from . import doctor as dr
+from . import wizard
+
+console = Console()
+app = typer.Typer(
+    help="datn — one-command distribution (ẩn docker compose).",
+    no_args_is_help=True,
+    add_completion=False,
+)
+config_app = typer.Typer(help="Cấu hình lại sau khi đã chạy.", no_args_is_help=False)
+app.add_typer(config_app, name="config")
+
+
+def _image_tag() -> str:
+    return cfg.read_lock().get("image_tag", cfg.DEFAULT_IMAGE_TAG)
+
+
+# ── init ─────────────────────────────────────────────────────────────────────
+@app.command()
+def init():
+    """Wizard cấu hình LLM + embedding → ghi ~/.datn/.env + provider.lock."""
+    # Nếu đã cấu hình trước đó (re-init), cần biết volumes có tồn tại không để
+    # guard đổi dim hoạt động → đảm bảo Docker chạy. Lần đầu (chưa config) thì
+    # bỏ qua, không bắt user bật Docker chỉ để nhập key.
+    volumes = False
+    if cfg.is_configured():
+        if dr.ensure_docker(auto_start=True):
+            volumes = cm.volumes_exist()
+        else:
+            console.print(
+                "[yellow]⚠ Docker không chạy — bỏ qua kiểm tra volume. "
+                "Nếu đổi embedding dim, hãy chạy `datn reset` thủ công.[/yellow]"
+            )
+    wizard.run_init(image_tag=cfg.DEFAULT_IMAGE_TAG, volumes_exist=volumes)
+
+
+# ── up ───────────────────────────────────────────────────────────────────────
+@app.command()
+def up():
+    """Pull images + khởi động toàn bộ stack + chờ healthy."""
+    if not cfg.is_configured():
+        console.print("[red]Chưa cấu hình. Chạy [bold]datn init[/bold] trước.[/red]")
+        raise typer.Exit(1)
+
+    if not dr.run_doctor(require_config=True):
+        console.print("[red]✗ doctor phát hiện lỗi blocking. Sửa rồi chạy lại.[/red]")
+        raise typer.Exit(1)
+
+    tag = _image_tag()
+    cm.render_compose(tag)
+    try:
+        cm.pull()
+        cm.up()
+    except subprocess.CalledProcessError as e:
+        console.print(
+            f"[bold red]✗ docker compose lỗi (exit {e.returncode}).[/bold red]\n"
+            f"  Xem lỗi docker cụ thể ở ngay phía trên. Nguyên nhân thường gặp:\n"
+            f"    • Port bận (port is already allocated) → đóng app/stack khác chiếm port; chạy [cyan]datn doctor[/cyan]\n"
+            f"    • Image tag '{tag}' chưa có trên Docker Hub / mạng lỗi → kiểm tra [cyan]docker pull {cfg.BACKEND_IMAGE}:{tag}[/cyan]\n"
+            f"    • Container crash → xem [cyan]datn logs[/cyan]"
+        )
+        raise typer.Exit(1)
+    if cm.wait_healthy():
+        console.print(f"\n[bold green]✓ Hệ thống sẵn sàng![/bold green] → {cfg.WEB_URL}")
+        console.print("[dim]Mở bằng: datn open[/dim]")
+    else:
+        console.print("[red]Một số service chưa healthy. Kiểm tra: datn logs[/red]")
+        raise typer.Exit(1)
+
+
+# ── down / open / logs ───────────────────────────────────────────────────────
+@app.command()
+def down():
+    """Dừng stack (giữ data)."""
+    cm.down()
+    console.print("[green]✓ Đã dừng (data được giữ).[/green]")
+
+
+@app.command()
+def open():  # noqa: A001 — tên lệnh user-facing
+    """Mở web UI trên trình duyệt."""
+    console.print(f"→ Mở {cfg.WEB_URL}")
+    webbrowser.open(cfg.WEB_URL)
+
+
+@app.command()
+def logs(service: str = typer.Argument(None, help="Tên service (vd agent-api). Bỏ trống = tất cả.")):
+    """Xem logs realtime."""
+    cm.logs(service)
+
+
+# ── doctor ───────────────────────────────────────────────────────────────────
+@app.command()
+def doctor():
+    """Kiểm tra môi trường (Docker, ports, config, dim...)."""
+    require = cfg.is_configured()
+    ok = dr.run_doctor(require_config=require)
+    raise typer.Exit(0 if ok else 1)
+
+
+# ── reset / update / uninstall ───────────────────────────────────────────────
+@app.command()
+def reset():
+    """Xoá toàn bộ data (volumes) — bắt buộc khi đổi embedding dim."""
+    if not Confirm.ask(
+        "[bold red]Xoá toàn bộ data RAG + chat history?[/bold red]", default=False
+    ):
+        console.print("Đã huỷ.")
+        return
+    cm.reset()
+    console.print("[green]✓ Đã xoá volumes. Chạy datn init + datn up để bắt đầu lại.[/green]")
+
+
+@app.command()
+def update(tag: str = typer.Option(None, "--tag", help="Image tag mới (vd v0.2.0).")):
+    """Đổi image tag → re-render + pull + up lại."""
+    lock = cfg.read_lock()
+    if tag:
+        lock["image_tag"] = tag
+        cfg.write_lock(lock)
+    new_tag = lock.get("image_tag", cfg.DEFAULT_IMAGE_TAG)
+    cm.render_compose(new_tag)
+    try:
+        cm.pull()
+        cm.up()
+    except subprocess.CalledProcessError as e:
+        console.print(f"[bold red]✗ docker compose lỗi (exit {e.returncode}). Tag '{new_tag}' đã push chưa?[/bold red]")
+        raise typer.Exit(1)
+    console.print(f"[green]✓ Đã cập nhật lên tag '{new_tag}'.[/green]")
+
+
+@app.command()
+def uninstall():
+    """down -v + xoá ~/.datn/ (giữ images đã pull)."""
+    if not Confirm.ask(
+        "[bold red]Gỡ datn: xoá data + cấu hình ~/.datn?[/bold red]", default=False
+    ):
+        console.print("Đã huỷ.")
+        return
+    try:
+        cm.reset()
+    except Exception:
+        pass
+    shutil.rmtree(cfg.datn_home(), ignore_errors=True)
+    console.print("[green]✓ Đã gỡ. (Images Docker vẫn còn — xoá tay nếu muốn.)[/green]")
+
+
+@app.command()
+def version():
+    """In version CLI."""
+    console.print(f"datn-cli {__version__}")
+
+
+# ── config sub-app ───────────────────────────────────────────────────────────
+def _after_env_change(restart: bool = True):
+    if restart and dr.docker_ready():
+        cm.restart_backend()
+
+
+@config_app.callback(invoke_without_command=True)
+def config_main(ctx: typer.Context):
+    """Không tham số → menu interactive."""
+    if ctx.invoked_subcommand is not None:
+        return
+    if not cfg.is_configured():
+        console.print("[red]Chưa có config. Chạy [bold]datn init[/bold].[/red]")
+        raise typer.Exit(1)
+    choice = Prompt.ask(
+        "Sửa mục nào?",
+        choices=["llm", "embedding", "tavily", "serpapi"],
+        default="llm",
+    )
+    {"llm": config_llm, "embedding": config_embedding,
+     "tavily": config_tavily, "serpapi": config_serpapi}[choice]()
+
+
+@config_app.command("llm")
+def config_llm():
+    """Đổi LLM provider/model/key → restart backend."""
+    env = cfg.read_env()
+    env.update(wizard.prompt_llm())
+    cfg.write_env(env)
+    lock = cfg.read_lock()
+    lock["llm_provider"] = env["LLM_PROVIDER"]
+    cfg.write_lock(lock)
+    console.print("[green]✓ Đã cập nhật LLM.[/green]")
+    _after_env_change()
+
+
+@config_app.command("embedding")
+def config_embedding():
+    """Đổi embedding → detect dim; nếu đổi dim + có data → bắt reset."""
+    try:
+        new = wizard.prompt_embedding()
+    except wizard.DimensionDetectError as e:
+        console.print(f"[red]✗ {e}[/red]")
+        raise typer.Exit(1)
+
+    lock = cfg.read_lock()
+    old_dim = lock.get("embedding_dim")
+    new_dim = int(new["EMBEDDING_DIM"])
+    if old_dim is not None and old_dim != new_dim and cm.volumes_exist():
+        console.print(
+            f"[bold red]✗ Đổi dim {old_dim}→{new_dim} sẽ vỡ collection. "
+            f"Chạy datn reset trước.[/bold red]"
+        )
+        raise typer.Exit(1)
+
+    env = cfg.read_env()
+    env.update(new)
+    cfg.write_env(env)
+    lock["embedding_provider"] = new["EMBEDDING_PROVIDER"]
+    lock["embedding_dim"] = new_dim
+    cfg.write_lock(lock)
+    console.print("[green]✓ Đã cập nhật embedding.[/green]")
+    _after_env_change()
+
+
+@config_app.command("tavily")
+def config_tavily():
+    """Đổi Tavily API key."""
+    env = cfg.read_env()
+    env["TAVILY_API_KEY"] = Prompt.ask("Tavily API Key", default="", show_default=False)
+    cfg.write_env(env)
+    console.print("[green]✓ Đã cập nhật Tavily.[/green]")
+    _after_env_change()
+
+
+@config_app.command("serpapi")
+def config_serpapi():
+    """Đổi SerpApi API key."""
+    env = cfg.read_env()
+    env["SERPAPI_API_KEY"] = Prompt.ask("SerpApi API Key", default="", show_default=False)
+    cfg.write_env(env)
+    console.print("[green]✓ Đã cập nhật SerpApi.[/green]")
+    _after_env_change()
+
+
+@config_app.command("set")
+def config_set(key: str = typer.Argument(...), value: str = typer.Argument(...)):
+    """Sửa nhanh 1 biến .env (cho người rành env)."""
+    env = cfg.read_env()
+    env[key] = value
+    cfg.write_env(env)
+    console.print(f"[green]✓ {key} = {value}[/green]")
+    _after_env_change()
+
+
+if __name__ == "__main__":
+    app()

datn_cli/compose.py

@@ -0,0 +1,139 @@
+"""Render compose template + bọc các lệnh docker compose."""
+from __future__ import annotations
+
+import platform
+import subprocess
+import time
+from importlib import resources
+
+import httpx
+from jinja2 import Template
+from rich.console import Console
+
+from . import config as cfg
+
+console = Console()
+
+_SYSTEM = platform.system()
+
+
+# ── Render template ──────────────────────────────────────────────────────────
+def _needs_host_gateway() -> bool:
+    """Linux + selfhost URL trỏ host.docker.internal → cần extra_hosts."""
+    if _SYSTEM != "Linux":
+        return False
+    env = cfg.read_env()
+    urls = (env.get("LLM_BASE_URL", ""), env.get("EMBEDDING_BASE_URL", ""))
+    return any("host.docker.internal" in u for u in urls)
+
+
+def render_compose(image_tag: str) -> None:
+    """Render docker-compose.yml vào ~/.datn/ từ template .j2."""
+    tpl_text = (
+        resources.files("datn_cli.templates")
+        .joinpath("docker-compose.dist.yml.j2")
+        .read_text(encoding="utf-8")
+    )
+    rendered = Template(tpl_text).render(
+        backend_image=cfg.BACKEND_IMAGE,
+        frontend_image=cfg.FRONTEND_IMAGE,
+        image_tag=image_tag,
+        env_file=str(cfg.env_path()),
+        needs_host_gateway=_needs_host_gateway(),
+    )
+    cfg.compose_path().write_text(rendered, encoding="utf-8")
+
+
+# ── docker compose wrappers ──────────────────────────────────────────────────
+def _compose(*args: str, check: bool = True, capture: bool = False) -> subprocess.CompletedProcess:
+    # -p datn: pin project name → volume luôn có prefix 'datn_' (deterministic,
+    # không phụ thuộc thư mục chứa compose file). volumes_exist() dựa vào điều này.
+    cmd = ["docker", "compose", "-p", cfg.PROJECT_NAME, "-f", str(cfg.compose_path()), *args]
+    return subprocess.run(cmd, check=check, capture_output=capture, text=True)
+
+
+def volumes_exist() -> bool:
+    """Có volume của project 'datn' nào đang tồn tại không (để guard đổi dim).
+
+    Vì _compose pin -p datn, volume thực tế có dạng 'datn_datn_<name>'. Lọc theo
+    prefix project để không nhầm với volume của dự án khác.
+    """
+    try:
+        r = subprocess.run(
+            ["docker", "volume", "ls", "--format", "{{.Name}}"],
+            capture_output=True, text=True, timeout=10,
+        )
+        prefix = f"{cfg.PROJECT_NAME}_"
+        return any(v.startswith(prefix) for v in r.stdout.split())
+    except Exception:
+        return False
+
+
+def pull() -> None:
+    console.print("[cyan]Pulling images từ Docker Hub...[/cyan]")
+    console.print("[dim]⚠ Lần đầu có thể mất vài phút (~2-4GB).[/dim]")
+    _compose("pull")
+
+
+def up() -> None:
+    console.print("[cyan]Khởi động services...[/cyan]")
+    _compose("up", "-d")
+
+
+def down() -> None:
+    _compose("down")
+
+
+def reset() -> None:
+    """down -v — xoá volumes (mất data RAG + chat history)."""
+    _compose("down", "-v")
+
+
+def logs(service: str | None = None) -> None:
+    args = ["logs", "-f"]
+    if service:
+        args.append(service)
+    _compose(*args, check=False)
+
+
+# ── Health polling ───────────────────────────────────────────────────────────
+def wait_healthy(timeout: int = 120) -> bool:
+    """Poll agent-api `/` + qdrant readiness tới khi healthy hoặc hết giờ."""
+    console.print("[cyan]Chờ services healthy...[/cyan]")
+    # Poll /health (200) — KHÔNG dùng "/" vì api.py không có route đó (trả 404,
+    # sẽ false-positive). /health do api.py expose riêng cho mục đích này.
+    api_url = f"http://localhost:{cfg.PORTS['agent-api']}/health"
+    qdrant_url = f"http://localhost:{cfg.PORTS['qdrant']}/readyz"
+
+    deadline = time.time() + timeout
+    api_ok = qdrant_ok = False
+    while time.time() < deadline:
+        if not qdrant_ok:
+            try:
+                qdrant_ok = httpx.get(qdrant_url, timeout=3).status_code == 200
+                if qdrant_ok:
+                    console.print("[green]✓[/green] qdrant")
+            except Exception:
+                pass
+        if not api_ok:
+            try:
+                api_ok = httpx.get(api_url, timeout=3).status_code == 200
+                if api_ok:
+                    console.print("[green]✓[/green] agent-api")
+            except Exception:
+                pass
+        if api_ok and qdrant_ok:
+            return True
+        time.sleep(3)
+
+    if not qdrant_ok:
+        console.print("[red]✗ qdrant không healthy. Xem: datn logs qdrant[/red]")
+    if not api_ok:
+        console.print("[red]✗ agent-api không healthy. Xem: datn logs agent-api[/red]")
+    return False
+
+
+def restart_backend() -> None:
+    """Restart agent-api + mcp-server để nạp .env mới (không mất data)."""
+    console.print("[cyan]Restart backend để nạp cấu hình mới...[/cyan]")
+    _compose("up", "-d", "--force-recreate", "agent-api", "mcp-server")

datn_cli/config.py

@@ -0,0 +1,137 @@
+"""Đường dẫn + đọc/ghi ~/.datn/.env và provider.lock."""
+from __future__ import annotations
+
+import json
+import os
+import stat
+from pathlib import Path
+
+# Image tag mặc định — phải khớp tag đã push lên Docker Hub (xem notes.md mục C/F).
+DEFAULT_IMAGE_TAG = "latest"
+
+# Compose project name — pin để volume naming deterministic (xem compose.py).
+PROJECT_NAME = "datn"
+
+# Docker Hub images
+BACKEND_IMAGE = "ngoquan0904/datn-backend"
+FRONTEND_IMAGE = "ngoquan0904/datn-frontend"
+
+# Cổng dùng trên host (để doctor kiểm tra + in URL)
+PORTS = {
+    "frontend": 5173,
+    "agent-api": 5000,
+    "mcp-server": 8000,
+    "postgres": 5432,
+    "qdrant": 6333,
+    "minio": 9000,
+    "minio-console": 9001,
+}
+
+WEB_URL = f"http://localhost:{PORTS['frontend']}"
+
+# Field bắt buộc trong .env để hệ thống chạy
+REQUIRED_ENV_FIELDS = [
+    "LLM_PROVIDER",
+    "LLM_MODEL",
+    "EMBEDDING_PROVIDER",
+    "EMBEDDING_MODEL",
+    "EMBEDDING_DIM",
+]
+
+
+def datn_home() -> Path:
+    """Thư mục cấu hình ~/.datn (tạo nếu chưa có)."""
+    home = Path(os.path.expanduser("~")) / ".datn"
+    home.mkdir(parents=True, exist_ok=True)
+    return home
+
+
+def env_path() -> Path:
+    return datn_home() / ".env"
+
+
+def lock_path() -> Path:
+    return datn_home() / "provider.lock"
+
+
+def compose_path() -> Path:
+    return datn_home() / "docker-compose.yml"
+
+
+# ── .env IO ─────────────────────────────────────────────────────────────────
+def read_env() -> dict[str, str]:
+    """Đọc .env thành dict (bỏ qua comment/dòng trống)."""
+    path = env_path()
+    if not path.exists():
+        return {}
+    data: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, val = line.partition("=")
+        data[key.strip()] = val.strip()
+    return data
+
+
+def write_env(data: dict[str, str]) -> None:
+    """Ghi .env theo thứ tự khối + chmod 600 (chỉ owner đọc — không lộ key)."""
+    order = [
+        ("# === LLM ===", None),
+        (None, "LLM_PROVIDER"),
+        (None, "LLM_API_KEY"),
+        (None, "LLM_MODEL"),
+        (None, "LLM_BASE_URL"),
+        (None, "LLM_DISABLE_THINKING"),
+        ("# === EMBEDDING ===", None),
+        (None, "EMBEDDING_PROVIDER"),
+        (None, "EMBEDDING_API_KEY"),
+        (None, "EMBEDDING_MODEL"),
+        (None, "EMBEDDING_BASE_URL"),
+        (None, "EMBEDDING_DIM"),
+        # Sub-agent keys (Tavily/SerpApi/Unsplash) KHÔNG ghi mặc định — đã bake trong
+        # image. Chỉ xuất hiện nếu user set tay (datn config set) → vào nhánh "extra".
+    ]
+    lines: list[str] = []
+    written: set[str] = set()
+    for comment, key in order:
+        if comment:
+            if lines:
+                lines.append("")
+            lines.append(comment)
+        elif key is not None:
+            lines.append(f"{key}={data.get(key, '')}")
+            written.add(key)
+    # Giữ lại field lạ (nếu user thêm tay) ở cuối
+    extra = [k for k in data if k not in written]
+    if extra:
+        lines.append("")
+        lines.append("# === Extra ===")
+        for k in extra:
+            lines.append(f"{k}={data[k]}")
+
+    path = env_path()
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    try:
+        path.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600
+    except OSError:
+        pass  # Windows có thể không hỗ trợ chmod đầy đủ — bỏ qua
+
+
+# ── provider.lock IO ─────────────────────────────────────────────────────────
+def read_lock() -> dict:
+    path = lock_path()
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+
+
+def write_lock(data: dict) -> None:
+    lock_path().write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+
+def is_configured() -> bool:
+    return env_path().exists()

datn_cli/doctor.py

@@ -0,0 +1,223 @@
+"""`datn doctor` — kiểm tra môi trường trước khi `up`.
+
+Thứ tự: dừng ở lỗi blocking, tiếp tục với warning. Tự khởi động Docker nếu
+daemon chưa chạy (Mac/Linux/Windows).
+"""
+from __future__ import annotations
+
+import platform
+import shutil
+import socket
+import subprocess
+import time
+
+from rich.console import Console
+
+from . import config as cfg
+
+console = Console()
+
+_SYSTEM = platform.system()  # "Linux" | "Darwin" | "Windows"
+
+
+# ── Docker daemon ────────────────────────────────────────────────────────────
+def docker_ready() -> bool:
+    try:
+        r = subprocess.run(
+            ["docker", "info"],
+            capture_output=True,
+            timeout=10,
+        )
+        return r.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def docker_installed() -> bool:
+    return shutil.which("docker") is not None
+
+
+def _start_docker_daemon() -> None:
+    """Khởi động Docker theo platform (không chờ — caller poll riêng)."""
+    try:
+        if _SYSTEM == "Darwin":
+            subprocess.Popen(["open", "-a", "Docker"])
+        elif _SYSTEM == "Linux":
+            # sudo -n: non-interactive. Nếu cần password mà không có TTY → fail ngay
+            # thay vì treo 30s. Khi đó in hướng dẫn thủ công.
+            r = subprocess.run(
+                ["sudo", "-n", "systemctl", "start", "docker"],
+                capture_output=True, timeout=15,
+            )
+            if r.returncode != 0:
+                console.print(
+                    "  [yellow]Không tự start được (cần quyền). Chạy tay:[/yellow] "
+                    "[cyan]sudo systemctl start docker[/cyan]"
+                )
+        elif _SYSTEM == "Windows":
+            subprocess.Popen(
+                ['C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe'],
+                shell=True,
+            )
+    except Exception:
+        pass
+
+
+def ensure_docker(auto_start: bool = True) -> bool:
+    """Đảm bảo Docker chạy. Tự start + chờ tối đa 60s nếu cần."""
+    if docker_ready():
+        return True
+    if not docker_installed():
+        console.print("[bold red]✗ Docker chưa cài.[/bold red]")
+        if _SYSTEM == "Linux":
+            console.print("  Cài: [cyan]curl -fsSL https://get.docker.com | sh[/cyan]")
+        else:
+            console.print("  Tải Docker Desktop: [cyan]https://www.docker.com/products/docker-desktop/[/cyan]")
+        return False
+    if not auto_start:
+        console.print("[red]✗ Docker chưa chạy.[/red]")
+        return False
+
+    console.print("[yellow]⚠ Docker chưa chạy — đang khởi động...[/yellow]")
+    _start_docker_daemon()
+    for _ in range(30):  # 30 × 2s = 60s
+        if docker_ready():
+            console.print("[green]✓ Docker sẵn sàng[/green]")
+            return True
+        time.sleep(2)
+    console.print("[red]✗ Docker không khởi động được sau 60s. Mở Docker Desktop thủ công.[/red]")
+    return False
+
+
+# ── Linux docker group ───────────────────────────────────────────────────────
+def _check_docker_group() -> tuple[bool, str]:
+    if _SYSTEM != "Linux":
+        return True, ""
+    try:
+        groups = subprocess.run(["id", "-nG"], capture_output=True, text=True, timeout=5).stdout
+        if "docker" in groups.split():
+            return True, ""
+        return False, (
+            "User chưa thuộc nhóm 'docker'. Chạy:\n"
+            "    [cyan]sudo usermod -aG docker $USER[/cyan]\n"
+            "  rồi [bold]đăng xuất + đăng nhập lại[/bold] (group mới có hiệu lực)."
+        )
+    except Exception:
+        return True, ""
+
+
+# ── Disk / RAM ───────────────────────────────────────────────────────────────
+def _check_disk() -> tuple[bool, str]:
+    try:
+        free_gb = shutil.disk_usage("/").free / (1024 ** 3)
+        if free_gb < 5:
+            return False, f"Chỉ còn {free_gb:.1f}GB trống (cần ~5GB cho images)."
+        return True, ""
+    except Exception:
+        return True, ""
+
+
+def _check_ram() -> tuple[bool, str]:
+    # Đọc /proc/meminfo trên Linux; bỏ qua trên Mac/Windows (không có psutil dep).
+    if _SYSTEM != "Linux":
+        return True, ""
+    try:
+        with open("/proc/meminfo") as f:
+            for line in f:
+                if line.startswith("MemAvailable:"):
+                    kb = int(line.split()[1])
+                    gb = kb / (1024 ** 2)
+                    if gb < 2:
+                        return False, f"RAM khả dụng {gb:.1f}GB (<2GB) — Qdrant+Postgres có thể nặng."
+                    return True, ""
+    except Exception:
+        pass
+    return True, ""
+
+
+# ── Ports ────────────────────────────────────────────────────────────────────
+def _port_in_use(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.settimeout(0.5)
+        return s.connect_ex(("127.0.0.1", port)) == 0
+
+
+def _check_ports() -> tuple[bool, str]:
+    busy = [name + f":{p}" for name, p in cfg.PORTS.items() if _port_in_use(p)]
+    if busy:
+        return False, "Cổng đang bận: " + ", ".join(busy) + " (đóng app chiếm cổng hoặc đổi)."
+    return True, ""
+
+
+# ── .env / dim ───────────────────────────────────────────────────────────────
+def _check_env() -> tuple[bool, str]:
+    if not cfg.env_path().exists():
+        return False, "Chưa có ~/.datn/.env. Chạy [bold]datn init[/bold] trước."
+    data = cfg.read_env()
+    missing = [k for k in cfg.REQUIRED_ENV_FIELDS if not data.get(k)]
+    if missing:
+        return False, "Thiếu field bắt buộc: " + ", ".join(missing) + ". Chạy [bold]datn init[/bold]."
+    return True, ""
+
+
+def _check_dim_lock() -> tuple[bool, str]:
+    data = cfg.read_env()
+    lock = cfg.read_lock()
+    env_dim = data.get("EMBEDDING_DIM")
+    lock_dim = lock.get("embedding_dim")
+    if env_dim and lock_dim is not None and str(lock_dim) != str(env_dim):
+        return False, (
+            f"embedding_dim lệch: .env={env_dim} vs lock={lock_dim}. "
+            "Chạy [bold]datn reset[/bold] rồi [bold]datn init[/bold]."
+        )
+    return True, ""
+
+
+def _check_wsl() -> tuple[bool, str]:
+    if _SYSTEM != "Windows":
+        return True, ""
+    try:
+        r = subprocess.run(["wsl", "--status"], capture_output=True, timeout=10)
+        if r.returncode != 0:
+            return False, "WSL2 chưa sẵn sàng. Chạy [cyan]wsl --install[/cyan] (cần reboot)."
+        return True, ""
+    except Exception:
+        return False, "Không kiểm tra được WSL. Docker Desktop cần WSL2."
+
+
+# ── Orchestration ────────────────────────────────────────────────────────────
+def run_doctor(require_config: bool = True, auto_start_docker: bool = True) -> bool:
+    """Chạy toàn bộ check. Trả True nếu không có lỗi blocking."""
+    console.print("[bold]=== datn doctor ===[/bold]")
+    ok = True
+
+    # 1. Docker (blocking, có auto-start)
+    if ensure_docker(auto_start=auto_start_docker):
+        console.print("[green]✓[/green] Docker daemon")
+    else:
+        return False  # không có Docker thì các check sau vô nghĩa
+
+    # 2-N: warning/blocking checks
+    checks = [
+        ("docker group", _check_docker_group(), True),
+        ("disk space", _check_disk(), False),
+        ("RAM", _check_ram(), False),
+        ("ports", _check_ports(), False),
+        ("WSL2", _check_wsl(), True),
+    ]
+    if require_config:
+        checks += [
+            ("config (.env)", _check_env(), True),
+            ("embedding dim lock", _check_dim_lock(), True),
+        ]
+
+    for name, (passed, msg), blocking in checks:
+        if passed:
+            console.print(f"[green]✓[/green] {name}")
+        elif blocking:
+            console.print(f"[bold red]✗[/bold red] {name}: {msg}")
+            ok = False
+        else:
+            console.print(f"[yellow]⚠[/yellow] {name}: {msg}")
+
+    return ok

datn_cli/embed_detect.py

@@ -0,0 +1,88 @@
+"""Xác định embedding dimension.
+
+- Provider có model phổ biến (openai/gemini/openrouter) → tra bảng tĩnh.
+- selfhost → gửi 1 test embed call (OpenAI schema) đo len vector thực tế.
+
+KHÔNG import backend code (CLI là package độc lập). Bảng dim được nhân bản
+từ infrastructure/model.py:get_embedding_dimension — giữ đồng bộ thủ công.
+"""
+from __future__ import annotations
+
+import httpx
+
+# Mirror của infrastructure/model.py — cập nhật cùng lúc nếu backend đổi.
+_DIMENSION_MAP = {
+    "text-embedding-3-small": 1536,
+    "text-embedding-3-large": 3072,
+    "text-embedding-ada-002": 1536,
+    "google/gemini-embedding-001": 3072,
+    "embedding-001": 3072,
+    "openai/text-embedding-3-small": 1536,
+    "openai/text-embedding-3-large": 3072,
+    "openai/text-embedding-ada-002": 1536,
+}
+
+
+class DimensionDetectError(RuntimeError):
+    """Không xác định được dim (endpoint sai / key sai / schema lạ)."""
+
+
+def known_dimension(model: str) -> int | None:
+    """Tra dim từ bảng tĩnh. None nếu không biết (vd model selfhost lạ)."""
+    if model in _DIMENSION_MAP:
+        return _DIMENSION_MAP[model]
+    for key, dim in _DIMENSION_MAP.items():
+        if key in model:
+            return dim
+    return None
+
+
+def detect_selfhost_dimension(base_url: str, model: str, api_key: str = "") -> int:
+    """Gửi test embed call tới endpoint OpenAI-compatible, đo dim.
+
+    Raise DimensionDetectError với thông điệp rõ ràng nếu thất bại.
+    """
+    url = base_url.rstrip("/") + "/embeddings"
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    try:
+        resp = httpx.post(
+            url,
+            headers=headers,
+            json={"model": model, "input": "test"},
+            timeout=30.0,
+        )
+    except httpx.ConnectError as e:
+        raise DimensionDetectError(
+            f"Không kết nối được tới {url}. Kiểm tra base_url + endpoint đang chạy.\n  ({e})"
+        )
+    except httpx.TimeoutException:
+        raise DimensionDetectError(f"Timeout khi gọi {url} (30s). Endpoint phản hồi quá chậm?")
+
+    if resp.status_code == 401:
+        raise DimensionDetectError(f"401 Unauthorized — sai API key cho {url}.")
+    if resp.status_code == 404:
+        raise DimensionDetectError(
+            f"404 Not Found — {url} không tồn tại. base_url có đúng dạng "
+            f"'http://host:port/v1' không?"
+        )
+    if resp.status_code >= 400:
+        raise DimensionDetectError(
+            f"HTTP {resp.status_code} từ {url}: {resp.text[:200]}"
+        )
+
+    try:
+        data = resp.json()
+        embedding = data["data"][0]["embedding"]
+    except (ValueError, KeyError, IndexError, TypeError):
+        raise DimensionDetectError(
+            f"Response không đúng OpenAI schema (cần data[0].embedding). "
+            f"Nhận: {resp.text[:200]}"
+        )
+
+    if not isinstance(embedding, list) or not embedding:
+        raise DimensionDetectError("embedding rỗng hoặc không phải list.")
+
+    return len(embedding)

datn_cli/templates/docker-compose.dist.yml.j2

@@ -0,0 +1,124 @@
+# Generated by datn-cli — KHÔNG sửa tay (chạy `datn config`/`datn update` để đổi).
+# Compose dist: pull images từ Docker Hub, KHÔNG bind-mount, KHÔNG --reload.
+services:
+  agent-api:
+    image: {{ backend_image }}:{{ image_tag }}
+    container_name: datn-agent-api
+    ports:
+      - "5000:8000"
+    command: uvicorn api:app --host 0.0.0.0 --port 8000
+    environment:
+      POSTGRES_HOST: postgres
+      POSTGRES_PORT: "5432"
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: chat_history
+      QDRANT_HOST: qdrant
+      QDRANT_PORT: "6333"
+      MINIO_HOST: minio
+      MINIO_PORT: "9000"
+      MINIO_ACCESS_KEY: minioadmin
+      MINIO_SECRET_KEY: minioadmin
+      STORAGE_BUCKET: documents
+      COLLECTION_NAME: documents
+      MCP_SERVER_URL: http://mcp-server:8000/sse
+    env_file:
+      - {{ env_file }}
+{%- if needs_host_gateway %}
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+{%- endif %}
+    depends_on:
+      postgres:
+        condition: service_healthy
+      qdrant:
+        condition: service_started
+      minio:
+        condition: service_started
+    restart: always
+
+  mcp-server:
+    image: {{ backend_image }}:{{ image_tag }}
+    container_name: datn-mcp-server
+    ports:
+      - "8000:8000"
+    command: python -m mcp_server.mcp_server
+    environment:
+      POSTGRES_HOST: postgres
+      POSTGRES_PORT: "5432"
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: chat_history
+      QDRANT_HOST: qdrant
+      QDRANT_PORT: "6333"
+      MINIO_HOST: minio
+      MINIO_PORT: "9000"
+      MINIO_ACCESS_KEY: minioadmin
+      MINIO_SECRET_KEY: minioadmin
+      STORAGE_BUCKET: documents
+      COLLECTION_NAME: documents
+    env_file:
+      - {{ env_file }}
+{%- if needs_host_gateway %}
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+{%- endif %}
+    depends_on:
+      postgres:
+        condition: service_healthy
+    restart: always
+
+  frontend:
+    image: {{ frontend_image }}:{{ image_tag }}
+    container_name: datn-frontend
+    ports:
+      - "5173:80"
+    depends_on:
+      - agent-api
+    restart: always
+
+  postgres:
+    image: postgres:16-alpine
+    container_name: datn-postgres
+    ports:
+      - "5432:5432"
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: chat_history
+    volumes:
+      - datn_postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    restart: always
+
+  qdrant:
+    image: qdrant/qdrant:v1.15.1
+    container_name: datn-qdrant
+    ports:
+      - "6333:6333"
+    volumes:
+      - datn_qdrant_data:/qdrant/storage
+    restart: always
+
+  minio:
+    image: quay.io/minio/minio
+    container_name: datn-minio
+    ports:
+      - "9000:9000"
+      - "9001:9001"
+    environment:
+      MINIO_ROOT_USER: minioadmin
+      MINIO_ROOT_PASSWORD: minioadmin
+    command: server /data --console-address ":9001"
+    volumes:
+      - datn_minio_data:/data
+    restart: always
+
+volumes:
+  datn_postgres_data:
+  datn_qdrant_data:
+  datn_minio_data:

datn_cli/wizard.py

@@ -0,0 +1,190 @@
+"""Wizard `datn init` + reconfigure `datn config`.
+
+Ghi ~/.datn/.env (chmod 600) + provider.lock. Embedding dim tự detect — KHÔNG
+hỏi user nhập tay. localhost trong selfhost URL được auto-replace để dùng được
+từ trong container.
+"""
+from __future__ import annotations
+
+import re
+
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+
+from . import config as cfg
+from .embed_detect import (
+    DimensionDetectError,
+    detect_selfhost_dimension,
+    known_dimension,
+)
+
+console = Console()
+
+LLM_PROVIDERS = ["openai", "openrouter", "gemini", "selfhost"]
+EMBEDDING_PROVIDERS = ["openai", "gemini", "openrouter", "selfhost"]
+
+# Gợi ý model mặc định theo provider
+_LLM_DEFAULTS = {
+    "openai": "gpt-4o-mini",
+    "openrouter": "openai/gpt-4o-mini",
+    "gemini": "gemini-2.5-flash",
+    "selfhost": "",
+}
+_EMBEDDING_DEFAULTS = {
+    "openai": "text-embedding-3-small",
+    "gemini": "google/gemini-embedding-001",
+    "openrouter": "google/gemini-embedding-001",
+    "selfhost": "",
+}
+
+
+def _fix_localhost(url: str) -> str:
+    """localhost/127.0.0.1 → host.docker.internal (để container gọi được host)."""
+    if not url:
+        return url
+    new = re.sub(r"\b(localhost|127\.0\.0\.1)\b", "host.docker.internal", url)
+    if new != url:
+        console.print(
+            f"  [yellow]↪ Đổi '{url}' → '{new}' (để chạy được từ trong container)[/yellow]"
+        )
+    return new
+
+
+# ── LLM section ──────────────────────────────────────────────────────────────
+def prompt_llm() -> dict[str, str]:
+    console.print("\n[bold cyan]── LLM Provider ──[/bold cyan]")
+    provider = Prompt.ask("  Provider", choices=LLM_PROVIDERS, default="openai")
+
+    if provider == "selfhost":
+        base_url = ""
+        while not base_url:
+            base_url = _fix_localhost(Prompt.ask("  Base URL (vd http://host:8000/v1)").strip())
+            if not base_url:
+                console.print("  [red]Base URL bắt buộc cho selfhost.[/red]")
+        api_key = Prompt.ask("  API Key (Enter nếu không cần)", default="", show_default=False)
+        model = ""
+        while not model:
+            model = Prompt.ask("  Model").strip()
+        # Model reasoning (Qwen/VNPT/DeepSeek-distill) cần tắt thinking để xuất
+        # đúng XML structured — nếu không, chuỗi suy luận rò vào output làm hỏng flow.
+        disable_thinking = Confirm.ask(
+            "  Model dạng reasoning (Qwen/VNPT...) — tắt chế độ thinking?", default=False
+        )
+    else:
+        base_url = ""
+        api_key = Prompt.ask("  API Key", password=True)
+        model = Prompt.ask("  Model", default=_LLM_DEFAULTS[provider])
+        disable_thinking = False
+
+    return {
+        "LLM_PROVIDER": provider,
+        "LLM_API_KEY": api_key,
+        "LLM_MODEL": model,
+        "LLM_BASE_URL": base_url,
+        "LLM_DISABLE_THINKING": "true" if disable_thinking else "",
+    }
+
+
+# ── Embedding section (dim auto-detect) ──────────────────────────────────────
+def prompt_embedding() -> dict[str, str]:
+    console.print("\n[bold cyan]── Embedding Provider ──[/bold cyan]")
+    provider = Prompt.ask("  Provider", choices=EMBEDDING_PROVIDERS, default="openai")
+
+    if provider == "selfhost":
+        base_url = _fix_localhost(Prompt.ask("  Base URL (vd http://host:8080/v1)"))
+        api_key = Prompt.ask("  API Key (Enter nếu không cần)", default="", show_default=False)
+        model = Prompt.ask("  Model")
+        console.print("  [dim]→ Đang kiểm tra endpoint + đo dimension...[/dim]")
+        dim = detect_selfhost_dimension(base_url, model, api_key)  # raise nếu lỗi
+        console.print(f"  [green]✓ Kết nối OK — dim = {dim}[/green]")
+    else:
+        base_url = ""
+        api_key = Prompt.ask("  API Key", password=True)
+        model = Prompt.ask("  Model", default=_EMBEDDING_DEFAULTS[provider])
+        dim = known_dimension(model)
+        if dim is None:
+            console.print(
+                f"  [yellow]⚠ Không rõ dim của '{model}', mặc định 1536. "
+                f"Nếu sai, embedding sẽ vỡ collection.[/yellow]"
+            )
+            dim = 1536
+        else:
+            console.print(f"  [green]✓ dim = {dim}[/green]")
+
+    return {
+        "EMBEDDING_PROVIDER": provider,
+        "EMBEDDING_API_KEY": api_key,
+        "EMBEDDING_MODEL": model,
+        "EMBEDDING_BASE_URL": base_url,
+        "EMBEDDING_DIM": str(dim),
+    }
+
+
+# ── Optional sub-agents ──────────────────────────────────────────────────────
+def prompt_optional() -> dict[str, str]:
+    # Tavily/SerpApi/Unsplash đã bake sẵn trong image (chủ dự án chia sẻ) → user
+    # KHÔNG cần nhập. Không ghi vào .env (rỗng sẽ override key bake). Ai muốn dùng
+    # key riêng: `datn config set TAVILY_API_KEY <key>`.
+    console.print(
+        "\n[dim]News/Travel/Slide đã có key dùng chung sẵn — bỏ qua. "
+        "Dùng key riêng? `datn config set TAVILY_API_KEY <key>`.[/dim]"
+    )
+    return {}
+
+
+# ── Orchestration ────────────────────────────────────────────────────────────
+def run_init(image_tag: str, volumes_exist: bool) -> bool:
+    """Chạy wizard đầy đủ. Trả False nếu user huỷ / bị guard chặn."""
+    console.print("[bold]=== datn init ===[/bold]")
+
+    if cfg.is_configured():
+        if not Confirm.ask(
+            "[yellow]Config đã tồn tại (~/.datn/.env). Ghi đè?[/yellow]", default=False
+        ):
+            console.print("Đã huỷ.")
+            return False
+
+    old_lock = cfg.read_lock()
+
+    try:
+        llm = prompt_llm()
+        embedding = prompt_embedding()
+    except DimensionDetectError as e:
+        console.print(f"\n[bold red]✗ Lỗi cấu hình embedding:[/bold red]\n  {e}")
+        console.print("[red]Không ghi .env. Sửa lại endpoint/key rồi chạy `datn init` lại.[/red]")
+        return False
+
+    optional = prompt_optional()
+
+    new_dim = int(embedding["EMBEDDING_DIM"])
+    old_dim = old_lock.get("embedding_dim")
+
+    # Guard đổi dim: dim mới ≠ dim cũ VÀ volumes đã có data → chặn, bắt reset
+    if old_dim is not None and old_dim != new_dim and volumes_exist:
+        console.print(
+            f"\n[bold red]✗ Đổi embedding dimension {old_dim} → {new_dim} "
+            f"sẽ vỡ Qdrant collection![/bold red]"
+        )
+        console.print(
+            "[red]Data RAG hiện tại dùng dim cũ. Chạy [bold]datn reset[/bold] "
+            "(xoá data) trước, rồi [bold]datn init[/bold] lại.[/red]"
+        )
+        return False
+
+    env_data = {**llm, **embedding, **optional}
+    cfg.write_env(env_data)
+    cfg.write_lock({
+        "llm_provider": llm["LLM_PROVIDER"],
+        "embedding_provider": embedding["EMBEDDING_PROVIDER"],
+        "embedding_dim": new_dim,
+        "image_tag": image_tag,
+    })
+
+    console.print(f"\n[green]✓ Đã ghi {cfg.env_path()} (chmod 600)[/green]")
+    console.print(f"[green]✓ Đã ghi {cfg.lock_path()}[/green]")
+    console.print(
+        "\n[dim]💡 Gmail/Calendar: cấu hình trong Settings sau khi `datn up` "
+        "(upload client_secret.json + Authorize).[/dim]"
+    )
+    console.print("\n[bold]Tiếp theo:[/bold] datn up")
+    return True

datn_cli-0.2.2.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: datn-cli
+Version: 0.2.2
+Summary: One-command distribution for the datn multi-agent assistant (hides docker compose).
+Author: ngoquan0904
+License: MIT
+Project-URL: Homepage, https://github.com/ngoquan0904/datn-cli
+Keywords: cli,docker,compose,ai-assistant,distribution
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: jinja2>=3.1
+
+# datn-cli
+
+Cài hệ trợ lý đa tác tử **datn** bằng 1 lệnh — CLI ẩn docker compose. Không cần source code.
+
+## Cài đặt (1 lệnh)
+
+**macOS / Linux:**
+```bash
+curl -fsSL https://raw.githubusercontent.com/ngoquan0904/datn-cli/main/install.sh | sh
+```
+
+**Windows (PowerShell):**
+```powershell
+irm https://raw.githubusercontent.com/ngoquan0904/datn-cli/main/install.ps1 | iex
+```
+
+Script tự cài: Python 3.9+, pipx, Docker (Linux) / WSL2+Docker Desktop (Windows), rồi `datn-cli`.
+
+## Chạy
+
+```bash
+datn init     # nhập API key cho LLM + embedding (chọn provider)
+datn up       # pull images + khởi động + chờ healthy (lần đầu mất vài phút)
+datn open     # mở http://localhost:5173
+```
+
+Trong `datn init` bạn chỉ cần **nhập API key**. Embedding dimension tự dò.
+Gmail/Calendar cấu hình sau trong **Settings** của web UI (upload `client_secret.json`).
+
+## Lệnh hay dùng
+
+| Lệnh | Việc |
+|---|---|
+| `datn doctor` | Kiểm tra Docker, ports, cấu hình |
+| `datn logs agent-api` | Xem log 1 service |
+| `datn down` | Dừng (giữ data) |
+| `datn config llm` | Đổi LLM provider/model/key |
+| `datn config embedding` | Đổi embedding (đổi dim → cần `datn reset`) |
+| `datn update --tag vX.Y.Z` | Cập nhật phiên bản image |
+| `datn reset` | Xoá data (RAG + chat history) |
+| `datn uninstall` | Gỡ data + cấu hình |
+
+## Self-host LLM/Embedding
+
+Chọn provider `selfhost` trong `datn init`, nhập `base_url` (OpenAI-compatible, vd vLLM/llama.cpp/Ollama).
+`localhost`/`127.0.0.1` tự đổi sang `host.docker.internal` để container gọi được host.
+
+## Troubleshooting
+
+| Triệu chứng | Cách xử lý |
+|---|---|
+| **Docker chưa cài** (macOS) | Tải Docker Desktop: https://www.docker.com/products/docker-desktop/ — script không tự cài được file .dmg |
+| **`permission denied` Docker (Linux)** | Đăng xuất + đăng nhập lại 1 lần (đã thêm bạn vào nhóm `docker`). Kiểm tra: `datn doctor` |
+| **WSL2 chưa có (Windows)** | Chạy lại `install.ps1` sau khi **khởi động lại máy** (script đã chạy `wsl --install`) |
+| **Port bận** (5000/8000/5173/5432/6333/9000) | `datn doctor` báo port + tiến trình. Đóng app chiếm port hoặc dừng stack cũ |
+| **Đĩa đầy khi pull** | Cần ~5GB trống cho images. Dọn ổ rồi `datn up` lại |
+| **Đổi embedding → lỗi dim** | `datn reset` (xoá data) → `datn init` → `datn up`. Đổi dim làm vỡ Qdrant collection |
+| **News/Travel báo "chưa cấu hình"** | Thiếu Tavily/SerpApi key — chạy `datn config tavily` / `datn config serpapi` (optional) |
+| **Image pull lỗi / tag không tồn tại** | Kiểm tra tag trong `~/.datn/provider.lock`; thử `datn update --tag latest` |
+
+## Yêu cầu hệ thống
+- RAM ≥ 4GB (Qdrant + Postgres + backend).
+- Đĩa trống ≥ 5GB (images ~2-4GB).
+- Kết nối Internet (pull images + gọi LLM API).

datn_cli-0.2.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+datn_cli/__init__.py,sha256=GQlHfc1MXNBzFbuhv7YG1b8fpb1imqfconHH4Lwj9r8,98
+datn_cli/__main__.py,sha256=LqTaFVA_VlN__pEvm9Gq9T-lriqp0J43jNWZZZwgiC4,9842
+datn_cli/compose.py,sha256=0Cc7IUyVh473SRgcB7Z4rWsA6y4TqC9ssi6s4_fkYpk,5234
+datn_cli/config.py,sha256=MM2E85RLevqyoiUpirOvd6O7RmAn5ctQfqbb5WLA9iM,4257
+datn_cli/doctor.py,sha256=v53StkCufA8ivnSb7okXBRPUaJrQnDBnNVv6brPu46Y,8708
+datn_cli/embed_detect.py,sha256=bIm_oPoO4LxEXlA2gUveAsfBUi6Aq3hwwGAWiqw14sI,3167
+datn_cli/wizard.py,sha256=6utheFz00zN3ZroGUHFIsFoVN_yvSh1kQF9MXSfHhD4,7736
+datn_cli/templates/docker-compose.dist.yml.j2,sha256=H8UULedNAslFQIHuBtu5ZaMUyBlAOIFHgLmkBrdHBOQ,3143
+datn_cli-0.2.2.dist-info/METADATA,sha256=i1qBa60GynElLTt8DSnySaudkfie_ojQ6GihkNperQA,3440
+datn_cli-0.2.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+datn_cli-0.2.2.dist-info/entry_points.txt,sha256=jrKnCK2Ta7w2AOHRYgJrwiGxLIGLOp3CW5MhiNkFHPM,47
+datn_cli-0.2.2.dist-info/top_level.txt,sha256=g0FBgLb8HtVXr8ofSMjFiKDel5_ygI0Mk5jcWd6clP4,9
+datn_cli-0.2.2.dist-info/RECORD,,

datn_cli-0.2.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

datn_cli-0.2.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+datn = datn_cli.__main__:app

datn_cli-0.2.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+datn_cli