sanka-cli 0.2.3__tar.gz → 0.2.4__tar.gz

{sanka_cli-0.2.3 → sanka_cli-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sanka-cli
-Version: 0.2.3
+Version: 0.2.4
 Summary: Sanka command-line interface and migration runtime
 Project-URL: Repository, https://github.com/sankaHQ/sanka
 Project-URL: Issues, https://github.com/sankaHQ/sanka/issues
@@ -149,3 +149,22 @@ The distribution license expression is
 `Apache-2.0 AND AGPL-3.0-only`. Both license texts and the historical hosted
 CLI notice ship in the wheel and source archive. File-level SPDX identifiers
 are authoritative.
+
+
+### Compact lifecycle output
+
+Use `--compact-dsl` instead of `--json` on `scan`, `plan`, `apply`, `test`,
+`verify`, and extension management commands when an agent needs a short result.
+The flags are mutually exclusive; `--json` retains its existing contract.
+Compact output starts with `sanka-compact/v1 <command> <outcome> <migration_state>`
+then emits one `key=JSON-value` per line. Strings use JSON escaping, including
+newlines and quotes. Failures, warnings, plan hashes, and limitations are retained.
+Legacy aliases are not repeated. With full artifacts available, generated file
+contents and route source code are replaced by explicit omission counts and file
+names. Read the returned artifact for those details; a compact summary is not a
+replacement for the full report. `data.plan_hash` becomes the `plan_hash` line;
+use that core hash for apply, not a nested extension hash.
+
+Keep the lifecycle: scan → plan → apply → test → verify. An applied scaffold with
+manual gaps is not complete. Test establishes generated scope; scenario verification
+checks HTTP and database parity within the supplied fixtures and cases.

{sanka_cli-0.2.3 → sanka_cli-0.2.4}/README.md

@@ -119,3 +119,22 @@ The distribution license expression is
 `Apache-2.0 AND AGPL-3.0-only`. Both license texts and the historical hosted
 CLI notice ship in the wheel and source archive. File-level SPDX identifiers
 are authoritative.
+
+
+### Compact lifecycle output
+
+Use `--compact-dsl` instead of `--json` on `scan`, `plan`, `apply`, `test`,
+`verify`, and extension management commands when an agent needs a short result.
+The flags are mutually exclusive; `--json` retains its existing contract.
+Compact output starts with `sanka-compact/v1 <command> <outcome> <migration_state>`
+then emits one `key=JSON-value` per line. Strings use JSON escaping, including
+newlines and quotes. Failures, warnings, plan hashes, and limitations are retained.
+Legacy aliases are not repeated. With full artifacts available, generated file
+contents and route source code are replaced by explicit omission counts and file
+names. Read the returned artifact for those details; a compact summary is not a
+replacement for the full report. `data.plan_hash` becomes the `plan_hash` line;
+use that core hash for apply, not a nested extension hash.
+
+Keep the lifecycle: scan → plan → apply → test → verify. An applied scaffold with
+manual gaps is not complete. Test establishes generated scope; scenario verification
+checks HTTP and database parity within the supplied fixtures and cases.

{sanka_cli-0.2.3 → sanka_cli-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sanka-cli"
-version = "0.2.3"
+version = "0.2.4"
 description = "Sanka command-line interface and migration runtime"
 readme = "README.md"
 requires-python = ">=3.12"

{sanka_cli-0.2.3 → sanka_cli-0.2.4}/src/sanka/cli/__init__.py

@@ -85,17 +85,21 @@ class _CliArgumentParser(argparse.ArgumentParser):
 
 def main(argv: list[str] | None = None) -> int:
     arguments = list(sys.argv[1:] if argv is None else argv)
-    json_errors = "--json" in arguments
+    json_errors = "--json" in arguments or "--compact-dsl" in arguments
     parser = _build_parser(json_errors=json_errors)
     try:
         args = parser.parse_args(arguments)
     except CliUsageError as error:
         command = arguments[0] if arguments and arguments[0] in SDK_COMMANDS else "sanka"
         return _print_cli_error(
-            argparse.Namespace(command=command, json=json_errors),
+            argparse.Namespace(
+                command=command, json=json_errors, compact_dsl="--compact-dsl" in arguments
+            ),
             error,
             exit_code=2,
         )
+    if getattr(args, "compact_dsl", False):
+        args.json = True
     if args.command is None:
         parser.print_help()
         return 0
@@ -173,12 +177,17 @@ def _json_result(
     return envelope
 
 
-def _print_json(payload: dict[str, Any]) -> None:
-    print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
+def _print_result(args: argparse.Namespace, payload: dict[str, Any]) -> None:
+    if getattr(args, "compact_dsl", False):
+        from sanka.cli._compact import render_compact
+
+        print(render_compact(payload))
+    else:
+        print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
 
 
 def _print_cli_error(args: argparse.Namespace, error: Exception, *, exit_code: int) -> int:
-    if getattr(args, "json", False):
+    if getattr(args, "json", False) or getattr(args, "compact_dsl", False):
         code = getattr(error, "code", None)
         details = getattr(error, "details", None)
         structured_error: dict[str, Any] = {
@@ -187,13 +196,14 @@ def _print_cli_error(args: argparse.Namespace, error: Exception, *, exit_code: i
         }
         if isinstance(details, dict) and details:
             structured_error["details"] = details
-        _print_json(
+        _print_result(
+            args,
             _json_result(
                 str(getattr(args, "command", "sanka") or "sanka"),
                 {"error": structured_error},
                 outcome="error",
                 migration_state="not_started" if exit_code == 2 else "failed",
-            )
+            ),
         )
     else:
         _terminal(args).failure(str(error))
@@ -221,9 +231,15 @@ def _build_parser(*, json_errors: bool = False) -> argparse.ArgumentParser:
 
     def presentation(sub: argparse.ArgumentParser, *, json_option: bool = True) -> None:
         if json_option:
-            sub.add_argument(
+            formats = sub.add_mutually_exclusive_group()
+            formats.add_argument(
                 "--json", action="store_true", help="print one sanka-cli/v1 JSON document"
             )
+            formats.add_argument(
+                "--compact-dsl",
+                action="store_true",
+                help="print a compact result; full generated code stays in artifacts",
+            )
         sub.add_argument("--no-color", action="store_true", help="disable ANSI color")
         detail = sub.add_mutually_exclusive_group()
         detail.add_argument("--quiet", action="store_true", help="print only outcome and errors")
@@ -414,7 +430,7 @@ def _build_parser(*, json_errors: bool = False) -> argparse.ArgumentParser:
         description=(
             "Check hashes, generated files, route coverage, and configured read-only HTTP "
             "comparisons. With --scenarios, replay a scenario file against the source "
-            "application and a candidate FastAPI app and diff status, body, declared "
+            "application and a candidate FastAPI or Flask app and diff status, body, declared "
             "headers, and database state; that mode needs no plan or generated manifest."
         ),
         epilog=(
@@ -436,6 +452,7 @@ def _build_parser(*, json_errors: bool = False) -> argparse.ArgumentParser:
         help="application repository root",
     )
     verify.add_argument("--to", help="select an application plan")
+    verify.add_argument("--settings", help="source Django settings module for scenario replay")
     verify.add_argument("--artifact-dir", default=DEFAULT_ARTIFACT_DIR)
     verify.add_argument("--output", default=None, help="generated FastAPI output directory")
     verify.add_argument(
@@ -667,8 +684,8 @@ def _extension_result(
     records: list[dict[str, Any]],
 ) -> int:
     data = {"operation": operation, "records": records}
-    if args.json:
-        _print_json(_json_result("extension", data, migration_state="not_started"))
+    if args.json or getattr(args, "compact_dsl", False):
+        _print_result(args, _json_result("extension", data, migration_state="not_started"))
         return 0
 
     terminal = _terminal(args)
@@ -895,8 +912,9 @@ def _print_application_result(
     *,
     migration_state: str,
 ) -> int:
-    if args.json:
-        _print_json(
+    if args.json or getattr(args, "compact_dsl", False):
+        _print_result(
+            args,
             _json_result(
                 command,
                 result.data,
@@ -904,7 +922,7 @@ def _print_application_result(
                 artifacts=list(result.artifacts),
                 limitations=list(result.limitations),
                 next_actions=list(result.next_actions),
-            )
+            ),
         )
     else:
         terminal = _terminal(args)
@@ -926,8 +944,9 @@ async def _cmd_plan(args: argparse.Namespace) -> int:
     engine = _engine(args.state)
     run_id = engine.create(spec)
     migration_plan = await engine.plan(run_id)
-    if args.json:
-        _print_json(
+    if args.json or getattr(args, "compact_dsl", False):
+        _print_result(
+            args,
             _json_result(
                 "plan",
                 {
@@ -953,7 +972,7 @@ async def _cmd_plan(args: argparse.Namespace) -> int:
                         ]
                     )
                 ],
-            )
+            ),
         )
     else:
         _print_plan(run_id, migration_plan)
@@ -995,8 +1014,9 @@ async def _cmd_apply(args: argparse.Namespace) -> int:
     if run.plan_json is None:
         raise ExecutionError("no plan for this spec yet; run `sanka plan` first")
     await engine.apply(run_id, plan_hash=args.plan_hash)
-    if args.json:
-        _print_json(
+    if args.json or getattr(args, "compact_dsl", False):
+        _print_result(
+            args,
             _json_result(
                 "apply",
                 {
@@ -1017,7 +1037,7 @@ async def _cmd_apply(args: argparse.Namespace) -> int:
                         ]
                     )
                 ],
-            )
+            ),
         )
     else:
         print(f"run {run_id}: applied")
@@ -1053,8 +1073,9 @@ async def _cmd_verify(args: argparse.Namespace) -> int:
     engine = _engine(args.state)
     run_id = engine.create(spec)
     verify_report = await engine.verify(run_id)
-    if args.json:
-        _print_json(
+    if args.json or getattr(args, "compact_dsl", False):
+        _print_result(
+            args,
             _json_result(
                 "verify",
                 {
@@ -1077,7 +1098,7 @@ async def _cmd_verify(args: argparse.Namespace) -> int:
                     "verified_within_scope" if verify_report.ok else "verification_failed"
                 ),
                 artifacts=[str(Path(args.state).resolve())],
-            )
+            ),
         )
     else:
         _print_verify(verify_report)

sanka_cli-0.2.4/src/sanka/cli/_compact.py

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+"""Model-facing presentation of the existing result, with JSON-escaped values."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def _summary(value: Any, *, path: tuple[str, ...] = (), artifacts: bool = False) -> Any:
+    if isinstance(value, dict):
+        if path in {("files",), ("extension", "files")} and artifacts:
+            return {"names": sorted(value), "omitted_file_contents": len(value)}
+        result = {}
+        for name, item in value.items():
+            if name == "extension" and isinstance(item, dict):
+                # Core lifecycle responses repeat extension fields; retain differing hashes.
+                item = {k: v for k, v in item.items() if k not in value or value[k] != v}
+                if not item:
+                    continue
+            if (
+                name == "source"
+                and {"classification", "method"} <= value.keys()
+                and isinstance(item, str)
+                and artifacts
+            ):
+                result["omitted_source_characters"] = len(item)
+            else:
+                result[name] = _summary(item, path=(*path, name), artifacts=artifacts)
+        return result
+    if isinstance(value, list):
+        return [_summary(item, path=(*path, "[]"), artifacts=artifacts) for item in value]
+    return value
+
+
+def render_compact(payload: dict[str, Any]) -> str:
+    """One header, then key=JSON lines. Never truncate failures, warnings or hashes."""
+    lines = [" ".join(str(payload[k]) for k in ("command", "outcome", "migration_state"))]
+    lines[0] = "sanka-compact/v1 " + lines[0]
+    data = _summary(payload["data"], artifacts=bool(payload.get("artifacts")))
+    for key, value in data.items():
+        # Escape even extension-defined keys so a newline cannot forge another record.
+        label = key if key.isidentifier() else json.dumps(key, ensure_ascii=False)
+        lines.append(label + "=" + json.dumps(value, ensure_ascii=False, separators=(",", ":")))
+    for key in ("artifacts", "limitations", "next_actions"):
+        if payload.get(key):
+            lines.append(
+                key + "=" + json.dumps(payload[key], ensure_ascii=False, separators=(",", ":"))
+            )
+    return "\n".join(lines)

{sanka_cli-0.2.3 → sanka_cli-0.2.4}/src/sanka/runtime/extensions/lifecycle.py

@@ -820,7 +820,7 @@ class ApplicationLifecycle:
         written, so the source fingerprint legitimately differs from any reviewed plan and
         a plan may not exist yet. The extension lock still has to match its recommendation
         exactly; only the plan, fingerprint, and artifact checks that guard apply and test
-        are skipped, because replay writes nothing into the project.
+        are skipped, because replay only writes verification artifacts in its artifact directory.
         """
         explicit_env_names = _canonical_environment_names(explicit_env_names)
         fingerprint = fingerprint_repository(self.project_root)
@@ -839,7 +839,6 @@ class ApplicationLifecycle:
         if result.outcome != "success":
             self._raise_failure(result)
         data = dict(result.data)
-        data["extension"] = result.data
         return ExtensionResult(
             outcome="success",
             data=data,

{sanka_cli-0.2.3 → sanka_cli-0.2.4}/src/sanka_cli/__init__.py

@@ -1,4 +1,4 @@
 # SPDX-License-Identifier: Apache-2.0
 __all__ = ["__version__"]
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"

{sanka_cli-0.2.3 → sanka_cli-0.2.4}/src/sanka_cli/client.py

@@ -87,16 +87,43 @@ class SankaApiClient:
         path: str,
         *,
         params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        max_bytes: int | None = None,
     ) -> tuple[bytes, dict[str, str]]:
         """Fetch a non-JSON body (currently only the Custom Code bundle download).
 
         Returns headers alongside the payload so the caller can verify the digest the
         server reports without a second request.
         """
+        request_headers = self._headers()
+        request_headers.update(headers or {})
+        if max_bytes is not None:
+            with self.client.stream(
+                method.upper(),
+                path,
+                headers=request_headers,
+                params=params,
+            ) as response:
+                content = bytearray()
+                for chunk in response.iter_bytes(chunk_size=65536):
+                    if len(content) + len(chunk) > max_bytes:
+                        raise APIError(
+                            status_code=413, message="API artifact exceeds its size limit"
+                        )
+                    content.extend(chunk)
+                if response.status_code >= 400:
+                    self._raise_for_response(
+                        httpx.Response(
+                            response.status_code,
+                            content=bytes(content),
+                            headers=response.headers,
+                        )
+                    )
+                return bytes(content), dict(response.headers)
         response = self.client.request(
             method.upper(),
             path,
-            headers=self._headers(),
+            headers=request_headers,
             params=params,
         )
         if response.status_code >= 400:

sanka_cli-0.2.4/src/sanka_cli/commands/cloud.py

@@ -0,0 +1,240 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Workspace-pinned client for hosted repository runs; no hosted implementation."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import io
+import re
+import zipfile
+from pathlib import Path
+from typing import Any
+
+import click
+
+import sanka_cli.runtime as runtime
+from sanka_cli.state import CLIState
+
+ROOT = "/v2/migrate/cloud-runs"
+SOURCE_BYTES = 8 * 1024 * 1024
+ARTIFACT_BYTES = 16 * 1024 * 1024
+WORKSPACE = click.option("--workspace", required=True, help="Exact workspace code (8 digits).")
+RUN = click.argument("run_id", type=click.UUID)
+
+
+def _headers(workspace: str) -> dict[str, str]:
+    if not re.fullmatch(r"\d{8}", workspace):
+        raise click.BadParameter("must be an 8-digit workspace code", param_hint="--workspace")
+    return {"X-Workspace-Code": workspace}
+
+
+def _digest(value: str) -> str:
+    if not re.fullmatch(r"[a-f0-9]{64}", value):
+        raise click.BadParameter("must be a lowercase SHA-256 digest", param_hint="--sha256")
+    return value
+
+
+def _data(payload: dict[str, Any]) -> dict[str, Any]:
+    data = payload.get("data", payload)
+    if not isinstance(data, dict):
+        raise click.ClickException("Cloud API returned an invalid response")
+    return data
+
+
+def _read(state: CLIState, workspace: str, path: str, **params: Any) -> dict[str, Any]:
+    return runtime.request_json(state, "GET", path, headers=_headers(workspace), params=params)
+
+
+@click.group()
+def cloud() -> None:
+    """Hosted DRF-to-FastAPI runs, credit receipts, and artifacts (when enabled)."""
+
+
+@cloud.command("upload")
+@WORKSPACE
+@click.argument("archive", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click.option("--yes", is_flag=True, help="Confirm uploading this ZIP to the selected workspace.")
+@click.pass_obj
+def upload(state: CLIState, workspace: str, archive: Path, yes: bool) -> None:
+    """Upload an explicit ZIP, returning its source ID and SHA-256; no compute charge."""
+    headers = _headers(workspace)
+    with archive.open("rb") as stream:
+        content = stream.read(SOURCE_BYTES + 1)
+    if not content or len(content) > SOURCE_BYTES:
+        raise click.ClickException("Source ZIP must contain between 1 byte and 8 MiB")
+    try:
+        with zipfile.ZipFile(io.BytesIO(content)) as bundle:
+            if not bundle.infolist():
+                raise ValueError("empty ZIP")
+    except (ValueError, zipfile.BadZipFile) as exc:
+        raise click.ClickException("Source must be a nonempty ZIP archive") from exc
+    sha256 = hashlib.sha256(content).hexdigest()
+    if not yes:
+        click.confirm(
+            f"Upload {archive.name} ({len(content)} bytes, SHA-256 {sha256}) "
+            f"to workspace {workspace}? Source retention: 7 days",
+            abort=True,
+        )
+    payload = runtime.request_json(
+        state,
+        "POST",
+        "/v2/migrate/cloud-sources",
+        headers=headers,
+        json_body={"sha256": sha256, "archive_base64": base64.b64encode(content).decode("ascii")},
+    )
+    if _data(payload).get("sha256") != sha256:
+        raise click.ClickException("Uploaded source digest does not match the selected ZIP")
+    runtime.emit_payload(payload, state)
+
+
+@cloud.command("run")
+@WORKSPACE
+@click.option("--source-id", required=True, type=click.UUID)
+@click.option("--sha256", required=True)
+@click.option("--max-credits", required=True, type=click.IntRange(1, 6000))
+@click.option("--timeout-seconds", default=600, show_default=True, type=click.IntRange(1, 3600))
+@click.option(
+    "--settings-module", default=None, help="Django settings module, e.g. config.settings."
+)
+@click.option(
+    "--idempotency-key",
+    required=True,
+    help="Unique intent key (8-200 characters). Reuse with identical inputs after a network error.",
+)
+@click.option("--yes", is_flag=True, help="Confirm the credit hold and paid execution.")
+@click.pass_obj
+def run(
+    state: CLIState,
+    workspace: str,
+    source_id: Any,
+    sha256: str,
+    max_credits: int,
+    timeout_seconds: int,
+    settings_module: str | None,
+    idempotency_key: str,
+    yes: bool,
+) -> None:
+    """Reserve the credit limit and queue one run. Retries keep the same source and key."""
+    headers = _headers(workspace)
+    _digest(sha256)
+    if (
+        not 8 <= len(idempotency_key) <= 200
+        or not idempotency_key.isascii()
+        or any(ord(char) < 33 or ord(char) > 126 for char in idempotency_key)
+    ):
+        raise click.BadParameter(
+            "must be 8-200 visible ASCII characters", param_hint="--idempotency-key"
+        )
+    if settings_module is not None and (
+        len(settings_module) > 200
+        or not re.fullmatch(r"[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*", settings_module)
+    ):
+        raise click.BadParameter("must be a Python module name", param_hint="--settings-module")
+    if not yes:
+        click.confirm(
+            f"Run source {source_id} in workspace {workspace}? "
+            f"Reserve up to {max_credits} credits; "
+            "100 credits per active worker-minute, unused credits released",
+            abort=True,
+        )
+    headers["Idempotency-Key"] = idempotency_key
+    payload = runtime.request_json(
+        state,
+        "POST",
+        ROOT,
+        headers=headers,
+        json_body={
+            "source_id": str(source_id),
+            "source_sha256": sha256,
+            "max_credits": max_credits,
+            "timeout_seconds": timeout_seconds,
+            "settings_module": settings_module,
+        },
+    )
+    runtime.emit_payload(payload, state)
+
+
+@cloud.command("list")
+@WORKSPACE
+@click.option("--cursor", type=click.UUID, default=None)
+@click.pass_obj
+def list_runs(state: CLIState, workspace: str, cursor: Any) -> None:
+    params = {"cursor": str(cursor)} if cursor else {}
+    runtime.emit_payload(_read(state, workspace, ROOT, limit=20, **params), state)
+
+
+@cloud.command("status")
+@WORKSPACE
+@RUN
+@click.pass_obj
+def status(state: CLIState, workspace: str, run_id: Any) -> None:
+    runtime.emit_payload(_read(state, workspace, f"{ROOT}/{run_id}"), state)
+
+
+@cloud.command("receipt")
+@WORKSPACE
+@RUN
+@click.pass_obj
+def receipt(state: CLIState, workspace: str, run_id: Any) -> None:
+    """Read the immutable receipt, including held, charged, and released credits."""
+    runtime.emit_payload(_read(state, workspace, f"{ROOT}/{run_id}/receipt"), state)
+
+
+@cloud.command("events")
+@WORKSPACE
+@RUN
+@click.option("--cursor", default=0, type=click.IntRange(min=0))
+@click.pass_obj
+def events(state: CLIState, workspace: str, run_id: Any, cursor: int) -> None:
+    runtime.emit_payload(_read(state, workspace, f"{ROOT}/{run_id}/events", cursor=cursor), state)
+
+
+@cloud.command("cancel")
+@WORKSPACE
+@RUN
+@click.pass_obj
+def cancel(state: CLIState, workspace: str, run_id: Any) -> None:
+    """Cancel this run; completed active compute can still be charged."""
+    runtime.emit_payload(
+        runtime.request_json(
+            state,
+            "POST",
+            f"{ROOT}/{run_id}/cancel",
+            headers=_headers(workspace),
+        ),
+        state,
+    )
+
+
+@cloud.command("download")
+@WORKSPACE
+@RUN
+@click.option("--artifact", type=click.Choice(["output.zip", "logs.txt"]), default="output.zip")
+@click.option("--to", "destination", required=True, type=click.Path(dir_okay=False, path_type=Path))
+@click.pass_obj
+def download(
+    state: CLIState, workspace: str, run_id: Any, artifact: str, destination: Path
+) -> None:
+    """Verify a retained artifact's digest and save a new file; existing files are preserved."""
+    if destination.exists() or destination.is_symlink():
+        raise click.ClickException("Destination already exists; choose a new file")
+    manifest = _data(_read(state, workspace, f"{ROOT}/{run_id}/artifacts"))
+    entries = manifest.get("artifacts", [])
+    metadata = next((item for item in entries if item.get("name") == artifact), None)
+    if metadata is None:
+        raise click.ClickException("Artifact is not available (it may have expired)")
+    content, _ = runtime.request_bytes(
+        state,
+        "GET",
+        f"{ROOT}/{run_id}/artifacts/{artifact}",
+        headers=_headers(workspace),
+        max_bytes=ARTIFACT_BYTES,
+    )
+    if len(content) != metadata.get("size_bytes") or hashlib.sha256(
+        content
+    ).hexdigest() != metadata.get("sha256"):
+        raise click.ClickException("Artifact size or digest does not match; no file was written")
+    with destination.open("xb") as stream:
+        stream.write(content)
+    runtime.emit_payload({"path": str(destination), "sha256": metadata["sha256"]}, state)

{sanka_cli-0.2.3 → sanka_cli-0.2.4}/src/sanka_cli/main.py

@@ -6,6 +6,7 @@ import click
 from sanka_cli import __version__
 from sanka_cli.commands.ai import ai
 from sanka_cli.commands.auth import auth, auth_login, auth_logout, auth_status
+from sanka_cli.commands.cloud import cloud
 from sanka_cli.commands.code import code
 from sanka_cli.commands.migrate import register_migration_passthroughs
 from sanka_cli.commands.profiles import profiles
@@ -44,6 +45,7 @@ cli.add_command(profiles)
 cli.add_command(workflows)
 cli.add_command(ai)
 cli.add_command(code)
+cli.add_command(cloud)
 cli.add_command(skill)
 
 attach_resource_group(cli, "companies", "/v2/public/companies")

{sanka_cli-0.2.3 → sanka_cli-0.2.4}/src/sanka_cli/runtime.py

@@ -148,10 +148,17 @@ def request_bytes(
     path: str,
     *,
     params: dict[str, Any] | None = None,
+    headers: dict[str, str] | None = None,
+    max_bytes: int | None = None,
 ) -> tuple[bytes, dict[str, str]]:
     client = build_client(state)
     try:
-        return client.request_bytes(method, path, params=params)
+        options: dict[str, Any] = {}
+        if headers is not None:
+            options["headers"] = headers
+        if max_bytes is not None:
+            options["max_bytes"] = max_bytes
+        return client.request_bytes(method, path, params=params, **options)
     except APIError as exc:
         handle_api_error(exc)
         raise