kctl-api 0.5.2__tar.gz → 0.5.3__tar.gz

{kctl_api-0.5.2 → kctl_api-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kctl-api
-Version: 0.5.2
+Version: 0.5.3
 Summary: Kodemeio API CLI - manage your FastAPI platform
 Author-email: Kodemeio <dev@kodeme.io>
 License-Expression: MIT

{kctl_api-0.5.2 → kctl_api-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kctl-api"
-version = "0.5.2"
+version = "0.5.3"
 description = "Kodemeio API CLI - manage your FastAPI platform"
 license = "MIT"
 requires-python = ">=3.12"

{kctl_api-0.5.2 → kctl_api-0.5.3}/src/kctl_api/__init__.py

@@ -1,3 +1,3 @@
 """kctl-api: Kodemeio API CLI."""
 
-__version__ = "0.5.2"
+__version__ = "0.5.3"

{kctl_api-0.5.2 → kctl_api-0.5.3}/src/kctl_api/commands/deploy.py

@@ -5,11 +5,14 @@ Status, logs, restart, and rollback via Dokploy API (stubs).
 
 from __future__ import annotations
 
+import contextlib
+import subprocess
 from typing import Annotated
 
 import typer
 
 from kctl_api.core.callbacks import AppContext
+from kctl_api.core.utils import find_project_root
 
 app = typer.Typer(name="deploy", help="Deployment management — status, logs, restart, rollback.", no_args_is_help=True)
 
@@ -36,11 +39,38 @@ def logs(
     ctx: typer.Context,
     app_name: Annotated[str, typer.Argument(help="App name.")],
     tail: Annotated[int, typer.Option("--tail", "-n", help="Number of lines.")] = 100,
+    follow: Annotated[bool, typer.Option("--follow", "-f", help="Follow logs in real time.")] = False,
+    compose_id: Annotated[
+        str | None,
+        typer.Option("--compose-id", help="Dokploy compose ID. Uses local docker compose when omitted."),
+    ] = None,
+    service: Annotated[str | None, typer.Option("--service", "-s", help="Runtime service/container name.")] = None,
+    dokploy_profile: Annotated[str | None, typer.Option("--dokploy-profile", help="kctl-dokploy profile name.")] = None,
 ) -> None:
-    """View deployment logs (will use Dokploy API)."""
+    """View deployment logs via kctl-dokploy or local docker compose."""
     actx: AppContext = ctx.obj
     out = actx.output
-    out.info(f"Not yet implemented. Will fetch last {tail} log lines for: {app_name}")
+
+    log_service = service or app_name
+    if compose_id:
+        cmd = ["kctl-dokploy"]
+        if dokploy_profile:
+            cmd.extend(["--profile", dokploy_profile])
+        cmd.extend(["compose", "service-logs", compose_id, "--service", log_service, "--tail", str(tail)])
+        if follow:
+            cmd.append("--follow")
+    else:
+        root = find_project_root()
+        cmd = ["docker", "compose", "-f", str(root / "docker-compose.yml"), "logs", "--tail", str(tail)]
+        if follow:
+            cmd.append("--follow")
+        cmd.append(log_service)
+
+    out.info(f"Streaming logs for {log_service} ({'Dokploy' if compose_id else 'local compose'}).")
+    with contextlib.suppress(KeyboardInterrupt):
+        result = subprocess.run(cmd, capture_output=False)
+        if result.returncode != 0:
+            raise typer.Exit(result.returncode)
 
 
 # ---------------------------------------------------------------------------

{kctl_api-0.5.2 → kctl_api-0.5.3}/src/kctl_api/commands/logs.py

@@ -6,16 +6,23 @@ Follow, search, and filter service logs via docker compose.
 from __future__ import annotations
 
 import contextlib
+import re
 import subprocess
 from typing import Annotated
 
 import typer
+from kctl_lib.logging_utils import extract_json_payload, filter_sticky_blocks, is_error_line
 
 from kctl_api.core.callbacks import AppContext
 from kctl_api.core.utils import find_project_root
 
 app = typer.Typer(name="logs", help="Log viewer — follow, errors, search, tail.", no_args_is_help=True)
 
+LOG_HEADER_RE = re.compile(
+    r"^(?:[^|]+\|\s*)?\d{4}-\d{2}-\d{2}[\sT].*?\b"
+    r"(?:DEBUG|INFO|NOTICE|WARN|WARNING|ERROR|CRITICAL|FATAL)\b"
+)
+
 
 def _compose_log_cmd(args: list[str]) -> list[str]:
     """Build a docker compose logs command."""
@@ -62,11 +69,7 @@ def errors(
         out.error(f"Failed to fetch logs: {result.stderr.strip()}")
         raise typer.Exit(1)
 
-    error_lines = [
-        line
-        for line in result.stdout.splitlines()
-        if any(kw in line.upper() for kw in ("ERROR", "CRITICAL", "FATAL", "EXCEPTION", "TRACEBACK"))
-    ]
+    error_lines = filter_sticky_blocks(result.stdout.splitlines(), is_match=is_error_line, header_regex=LOG_HEADER_RE)
 
     if not error_lines:
         out.success("No errors found in recent logs.")
@@ -151,24 +154,15 @@ def structured(
         out.error(f"Failed to fetch logs: {result.stderr.strip()}")
         raise typer.Exit(1)
 
-    import json
-
-    parsed: list[dict] = []
+    parsed: list[dict[str, object]] = []
     for line in result.stdout.splitlines():
-        # Try to extract JSON from lines (structlog may have container prefix)
-        json_start = line.find("{")
-        if json_start == -1:
-            continue
-        json_part = line[json_start:]
-        try:
-            entry = json.loads(json_part)
+        entry = extract_json_payload(line)
+        if entry is not None:
             parsed.append(entry)
-        except json.JSONDecodeError:
-            continue
 
     # Filter
     if level:
-        parsed = [e for e in parsed if e.get("level", e.get("severity", "")).lower() == level.lower()]
+        parsed = [e for e in parsed if str(e.get("level", e.get("severity", ""))).lower() == level.lower()]
     if event:
         parsed = [e for e in parsed if event.lower() in str(e.get("event", e.get("msg", ""))).lower()]
 
@@ -178,7 +172,7 @@ def structured(
 
     rows = [
         [
-            str(e.get("timestamp", e.get("time", ""))[:19]),
+            str(e.get("timestamp", e.get("time", "")))[:19],
             str(e.get("level", e.get("severity", ""))),
             str(e.get("event", e.get("msg", ""))),
             str(e.get("logger", e.get("name", ""))),
@@ -216,23 +210,16 @@ def correlation(
         out.error(f"Failed to fetch logs: {result.stderr.strip()}")
         raise typer.Exit(1)
 
-    import json
-
-    matching_lines: list[dict] = []
+    matching_lines: list[dict[str, object]] = []
     for line in result.stdout.splitlines():
         if request_id not in line:
             continue
 
-        # Try to parse as structured log
-        json_start = line.find("{")
-        if json_start >= 0:
-            try:
-                entry = json.loads(line[json_start:])
-                entry["_raw"] = line
-                matching_lines.append(entry)
-                continue
-            except json.JSONDecodeError:
-                pass
+        entry = extract_json_payload(line)
+        if entry is not None:
+            entry["_raw"] = line
+            matching_lines.append(entry)
+            continue
 
         # Plain text match
         matching_lines.append({"_raw": line, "event": line.strip()})
@@ -243,8 +230,8 @@ def correlation(
 
     out.header(f"Correlation Trace: {request_id} ({len(matching_lines)} entries)")
     for entry in matching_lines:
-        ts = entry.get("timestamp", entry.get("time", ""))[:19]
-        level = entry.get("level", entry.get("severity", "INFO"))
+        ts = str(entry.get("timestamp", entry.get("time", "")))[:19]
+        level = str(entry.get("level", entry.get("severity", "INFO")))
         event = entry.get("event", entry.get("msg", entry.get("_raw", "")))
         logger = entry.get("logger", entry.get("name", ""))
 

{kctl_api-0.5.2 → kctl_api-0.5.3}/tests/test_cli.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from typer.testing import CliRunner
 
+from kctl_api import __version__
 from kctl_api.cli import app
 
 runner = CliRunner()
@@ -13,7 +14,7 @@ def test_version() -> None:
     result = runner.invoke(app, ["--version"])
     assert result.exit_code == 0
     assert "kctl-api" in result.output
-    assert "0.1.0" in result.output
+    assert __version__ in result.output
 
 
 def test_help() -> None:

{kctl_api-0.5.2 → kctl_api-0.5.3}/tests/test_deploy.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import subprocess
+
 import pytest
 from typer.testing import CliRunner
 
@@ -59,27 +61,77 @@ class TestDeployStatus:
 
 
 # ---------------------------------------------------------------------------
-# deploy logs (stub)
+# deploy logs
 # ---------------------------------------------------------------------------
 class TestDeployLogs:
-    def test_logs_shows_app_name(self) -> None:
-        result = runner.invoke(app, ["deploy", "logs", "api-main"])
-        assert result.exit_code == 0
-        assert "api-main" in result.output
+    def test_logs_uses_local_compose_by_default(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        calls: list[list[str]] = []
+
+        def fake_run(cmd: list[str], capture_output: bool = False) -> subprocess.CompletedProcess[str]:
+            calls.append(cmd)
+            return subprocess.CompletedProcess(cmd, 0)
+
+        monkeypatch.setattr("kctl_api.commands.deploy.subprocess.run", fake_run)
 
-    def test_logs_default_tail(self) -> None:
         result = runner.invoke(app, ["deploy", "logs", "api-main"])
+
         assert result.exit_code == 0
-        assert "100" in result.output
+        assert calls
+        assert calls[0][-3:] == ["--tail", "100", "api-main"]
+
+    def test_logs_custom_tail(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        calls: list[list[str]] = []
+
+        def fake_run(cmd: list[str], capture_output: bool = False) -> subprocess.CompletedProcess[str]:
+            calls.append(cmd)
+            return subprocess.CompletedProcess(cmd, 0)
+
+        monkeypatch.setattr("kctl_api.commands.deploy.subprocess.run", fake_run)
 
-    def test_logs_custom_tail(self) -> None:
         result = runner.invoke(app, ["deploy", "logs", "api-main", "--tail", "50"])
-        assert result.exit_code == 0
-        assert "50" in result.output
 
-    def test_logs_not_implemented_message(self) -> None:
-        result = runner.invoke(app, ["deploy", "logs", "api-main"])
-        assert "not yet implemented" in result.output.lower()
+        assert result.exit_code == 0
+        assert calls[0][-3:] == ["--tail", "50", "api-main"]
+
+    def test_logs_uses_dokploy_service_logs_when_compose_id_is_given(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        calls: list[list[str]] = []
+
+        def fake_run(cmd: list[str], capture_output: bool = False) -> subprocess.CompletedProcess[str]:
+            calls.append(cmd)
+            return subprocess.CompletedProcess(cmd, 0)
+
+        monkeypatch.setattr("kctl_api.commands.deploy.subprocess.run", fake_run)
+
+        result = runner.invoke(
+            app,
+            [
+                "deploy",
+                "logs",
+                "api-main",
+                "--compose-id",
+                "cmp123",
+                "--dokploy-profile",
+                "prod",
+                "--service",
+                "api",
+                "--tail",
+                "50",
+            ],
+        )
+
+        assert result.exit_code == 0
+        assert calls[0] == [
+            "kctl-dokploy",
+            "--profile",
+            "prod",
+            "compose",
+            "service-logs",
+            "cmp123",
+            "--service",
+            "api",
+            "--tail",
+            "50",
+        ]
 
 
 # ---------------------------------------------------------------------------

kctl_api-0.5.3/tests/test_logs.py

@@ -0,0 +1,43 @@
+"""Tests for kctl-api log commands."""
+
+from __future__ import annotations
+
+import subprocess
+
+import pytest
+from typer.testing import CliRunner
+
+from kctl_api.cli import app
+
+runner = CliRunner()
+
+
+def test_errors_preserves_traceback_continuations(monkeypatch: pytest.MonkeyPatch) -> None:
+    stdout = "\n".join(
+        [
+            "api-1 | 2026-05-17 10:00:00 INFO startup ok",
+            "api-1 | 2026-05-17 10:00:01 ERROR request failed",
+            "api-1 | Traceback (most recent call last):",
+            'api-1 |   File "app.py", line 1, in handler',
+            "api-1 | ValueError: boom",
+            "api-1 | 2026-05-17 10:00:02 INFO next request ok",
+        ]
+    )
+
+    def fake_run(
+        cmd: list[str],
+        capture_output: bool = False,
+        text: bool = False,
+    ) -> subprocess.CompletedProcess[str]:
+        return subprocess.CompletedProcess(cmd, 0, stdout=stdout, stderr="")
+
+    monkeypatch.setattr("kctl_api.commands.logs.subprocess.run", fake_run)
+
+    result = runner.invoke(app, ["logs", "errors", "--tail", "50"])
+
+    assert result.exit_code == 0
+    assert "ERROR request failed" in result.output
+    assert 'File "app.py"' in result.output
+    assert "ValueError: boom" in result.output
+    assert "startup ok" not in result.output
+    assert "next request ok" not in result.output