contree-cli 0.2.3__py3-none-any.whl

contree_cli/cli/file.py

@@ -0,0 +1,179 @@
+"""Manage files in the session image.
+
+Subcommands:
+  edit (e)  Download a file from the session image, open it in $EDITOR
+            (or vi), and upload the modified version as a pending file
+            attachment. The change takes effect on the next `run`.
+
+  cp        Copy a local file into the session image as a pending file
+            attachment. The file is uploaded immediately but injected
+            into the container on the next `run`.
+
+Pending files are branch-aware — switching branches changes which
+files are visible.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import logging
+import os
+import shlex
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from contree_cli import CLIENT, SESSION_STORE, ArgumentsProtocol, SetupResult
+from contree_cli.client import ApiError, ContreeClient, resolve_image, stream_response
+from contree_cli.session import SessionStore
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class FileEditArgs(ArgumentsProtocol):
+    path: str
+    editor: str | None = None
+
+    @classmethod
+    def from_args(cls, ns: argparse.Namespace) -> FileEditArgs:
+        return cls(path=ns.path, editor=getattr(ns, "editor", None))
+
+
+@dataclass(frozen=True)
+class FileCpArgs(ArgumentsProtocol):
+    src: str
+    dest: str
+
+    @classmethod
+    def from_args(cls, ns: argparse.Namespace) -> FileCpArgs:
+        return cls(src=ns.src, dest=ns.dest)
+
+
+def setup_parser(p: argparse.ArgumentParser) -> SetupResult:
+    sub = p.add_subparsers(dest="file_action", required=True)
+    edit_p = sub.add_parser(
+        "edit", aliases=["e"],
+        help="Edit a file in the session image",
+    )
+    edit_p.add_argument(
+        "-e", "--editor", help="Editor command (default: $EDITOR or vi)",
+    )
+    edit_p.add_argument("path", help="Path inside image")
+    edit_p.set_defaults(handler=cmd_file_edit, load_args=FileEditArgs)
+
+    cp_p = sub.add_parser(
+        "cp", help="Copy a local file into the session image",
+    )
+    cp_p.add_argument("src", help="Local file path")
+    cp_p.add_argument("dest", help="Destination path inside image")
+    cp_p.set_defaults(handler=cmd_file_cp, load_args=FileCpArgs)
+
+    return cmd_file_edit, FileEditArgs
+
+
+def _file_sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        while chunk := f.read(256 * 1024):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _upload_and_record(
+    client: ContreeClient,
+    store: SessionStore,
+    local_path: Path,
+    instance_path: str,
+    title: str,
+) -> str:
+    """Upload a local file (with dedup) and record as pending."""
+    sha = _file_sha256(local_path)
+    try:
+        resp = client.get("/v1/files", params={"sha256": sha})
+        file_uuid = json.loads(resp.read())["uuid"]
+        logger.info("File already exists on server (%s)", file_uuid)
+    except ApiError as exc:
+        if exc.status != 404:
+            raise
+        data = local_path.read_bytes()
+        resp = client.request(
+            "POST", "/v1/files",
+            body=data,
+            headers={"Content-Type": "application/octet-stream"},
+        )
+        file_uuid = json.loads(resp.read())["uuid"]
+        logger.info("Uploaded %s (%s)", instance_path, file_uuid)
+
+    history_id = store.set_image(
+        store.current_image, kind="file", title=title,
+    )
+    store.add_pending_file(history_id, instance_path, str(file_uuid))
+    logger.info(
+        "Pending: %s -> %s (will be included in next run)",
+        instance_path, file_uuid,
+    )
+    return str(file_uuid)
+
+
+def cmd_file_edit(args: FileEditArgs) -> int | None:
+    client = CLIENT.get()
+    store = SESSION_STORE.get()
+    image_uuid = resolve_image(client, store.current_image)
+
+    # 1. Download to temp file (or create empty)
+    tmp_dir = Path(tempfile.mkdtemp(prefix="contree-"))
+    filename = Path(args.path).name or "file"
+    tmp_file = tmp_dir / filename
+    try:
+        resp = client.get(
+            f"/v1/inspect/{image_uuid}/download",
+            params={"path": args.path},
+        )
+        with tmp_file.open("wb") as f:
+            for chunk in stream_response(resp):
+                f.write(chunk)
+        logger.info("Downloaded %s to %s", args.path, tmp_file)
+    except ApiError as exc:
+        if exc.status != 404:
+            raise
+        tmp_file.write_bytes(b"")
+        logger.info("File %s not found, creating empty file", args.path)
+
+    # 2. Record original hash, open editor
+    original_hash = _file_sha256(tmp_file)
+    editor = args.editor or os.environ.get("EDITOR", "vi")
+    logger.info("Opening %s in %s", tmp_file, editor)
+    rc = subprocess.call(f"{editor} {shlex.quote(str(tmp_file))}", shell=True)
+    if rc != 0:
+        logger.error("Editor exited with code %d", rc)
+        return 1
+
+    # 3. Check for changes
+    new_hash = _file_sha256(tmp_file)
+    if new_hash == original_hash:
+        logger.info("No changes detected, skipping upload")
+        return None
+
+    # 4+5. Upload (with dedup) and record pending file
+    _upload_and_record(
+        client, store, tmp_file, args.path,
+        title=f"Change file {args.path}",
+    )
+    return None
+
+
+def cmd_file_cp(args: FileCpArgs) -> int | None:
+    client = CLIENT.get()
+    store = SESSION_STORE.get()
+    local_path = Path(args.src)
+    if not local_path.is_file():
+        logger.error("File not found: %s", args.src)
+        return 1
+    _upload_and_record(
+        client, store, local_path, args.dest,
+        title=f"Change file {args.dest}",
+    )
+    return None

contree_cli/cli/images.py

@@ -0,0 +1,88 @@
+"""List container images.
+
+Queries the Contree API for available images and displays them with
+their UUID, tag, and creation time. Supports filtering by tag prefix,
+UUID, date range, and tagged-only mode.
+
+Results are paginated automatically. Use --format to control output
+(default table, json, csv, etc.).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+from dataclasses import dataclass
+from contree_cli import CLIENT, FORMATTER, ArgumentsProtocol, SetupResult
+from contree_cli.types import parse_datetime
+
+logger = logging.getLogger(__name__)
+
+PAGE_SIZE = 100
+
+
+@dataclass(frozen=True)
+class ImagesArgs(ArgumentsProtocol):
+    prefix: str | None = None
+    uuid: str | None = None
+    tagged: bool = False
+    since: str | None = None
+    until: str | None = None
+
+    @classmethod
+    def from_args(cls, ns: argparse.Namespace) -> ImagesArgs:
+        return cls(
+            prefix=ns.prefix,
+            uuid=ns.uuid,
+            tagged=ns.tagged,
+            since=ns.since,
+            until=ns.until,
+        )
+
+
+def setup_parser(p: argparse.ArgumentParser) -> SetupResult:
+    p.add_argument("--prefix", help="Filter by tag prefix")
+    p.add_argument("--uuid", help="Filter by image UUID")
+    p.add_argument(
+        "--tagged", action="store_true",
+        help="Only show tagged images",
+    )
+    p.add_argument("--since", help="Show images after date/time or interval")
+    p.add_argument("--until", help="Show images before date/time or interval")
+    return cmd_images, ImagesArgs
+
+
+def cmd_images(args: ImagesArgs) -> None:
+    client = CLIENT.get()
+    formatter = FORMATTER.get()
+
+    base_params: dict[str, str] = {"limit": str(PAGE_SIZE)}
+    if args.prefix is not None:
+        base_params["tag"] = args.prefix
+    if args.uuid is not None:
+        base_params["uuid"] = args.uuid
+    if args.tagged:
+        base_params["tagged"] = "1"
+    if args.since is not None:
+        base_params["since"] = args.since
+    if args.until is not None:
+        base_params["until"] = args.until
+
+    offset = 0
+    while True:
+        params = {**base_params, "offset": str(offset)}
+        resp = client.get("/v1/images", params=params)
+        data = json.loads(resp.read())
+        images = data["images"]
+        if not images:
+            break
+        for image in images:
+            created_at = parse_datetime(image["created_at"])
+            formatter(
+                uuid=image["uuid"],
+                created_at=created_at,
+                tag=image.get("tag") or "",
+            )
+        if len(images) < PAGE_SIZE:
+            break
+        offset += len(images)

contree_cli/cli/kill.py

@@ -0,0 +1,86 @@
+"""Cancel a running operation.
+
+Sends a DELETE request to stop the specified operation. Use --all to
+cancel every active operation (PENDING, ASSIGNED, EXECUTING) in one go.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+from dataclasses import dataclass
+
+from contree_cli import CLIENT, ArgumentsProtocol, SetupResult
+from contree_cli.client import ApiError
+
+logger = logging.getLogger(__name__)
+
+PAGE_SIZE = 100
+ACTIVE_STATUSES = ("PENDING", "ASSIGNED", "EXECUTING")
+
+
+@dataclass(frozen=True)
+class KillArgs(ArgumentsProtocol):
+    uuid: str | None = None
+    all: bool = False
+
+    @classmethod
+    def from_args(cls, ns: argparse.Namespace) -> KillArgs:
+        return cls(uuid=ns.uuid, all=ns.all)
+
+
+def setup_parser(p: argparse.ArgumentParser) -> SetupResult:
+    target = p.add_mutually_exclusive_group(required=True)
+    target.add_argument("uuid", nargs="?", help="Operation UUID")
+    target.add_argument(
+        "--all", action="store_true",
+        help="Cancel all active operations",
+    )
+    return cmd_kill, KillArgs
+
+
+def _list_active(client: object) -> list[str]:
+    """Collect UUIDs of all active operations."""
+    from contree_cli.client import ContreeClient
+    assert isinstance(client, ContreeClient)
+    uuids: list[str] = []
+    for status in ACTIVE_STATUSES:
+        offset = 0
+        while True:
+            params = {
+                "status": status,
+                "limit": str(PAGE_SIZE),
+                "offset": str(offset),
+            }
+            resp = client.get("/v1/operations", params=params)
+            operations = json.loads(resp.read())
+            if not operations:
+                break
+            uuids.extend(op["uuid"] for op in operations)
+            if len(operations) < PAGE_SIZE:
+                break
+            offset += len(operations)
+    return uuids
+
+
+def cmd_kill(args: KillArgs) -> int | None:
+    client = CLIENT.get()
+
+    if args.all:
+        uuids = _list_active(client)
+        if not uuids:
+            logger.info("No active operations to cancel")
+            return None
+        failed = 0
+        for uuid in uuids:
+            try:
+                client.delete(f"/v1/operations/{uuid}")
+                logger.info("Cancelled operation %s", uuid)
+            except ApiError as exc:
+                logger.error("Failed to cancel %s: %s", uuid, exc)
+                failed += 1
+        return 1 if failed else None
+
+    client.delete(f"/v1/operations/{args.uuid}")
+    logger.info("Cancelled operation %s", args.uuid)
+    return None

contree_cli/cli/ls.py

@@ -0,0 +1,83 @@
+"""List files in the session image.
+
+Uses the /inspect/ API to list directory contents without spawning an
+instance. Defaults to the session working directory (set via `cd`).
+
+In default format, the API returns a pre-formatted text listing. In
+structured formats (json, csv, etc.) the response is cached per
+(image, path) for instant repeat queries.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, cast
+
+from contree_cli import CLIENT, FORMATTER, SESSION_STORE, ArgumentsProtocol, SetupResult
+from contree_cli.client import resolve_image
+from contree_cli.output import DefaultFormatter
+
+
+def setup_parser(p: argparse.ArgumentParser) -> SetupResult:
+    p.add_argument(
+        "path", nargs="?", default=None,
+        help="Path inside image (defaults to session cwd)",
+    )
+    return cmd_ls, LsArgs
+
+
+@dataclass(frozen=True)
+class LsArgs(ArgumentsProtocol):
+    path: str | None
+
+    @classmethod
+    def from_args(cls, ns: argparse.Namespace) -> LsArgs:
+        return cls(path=ns.path)
+
+
+def cmd_ls(args: LsArgs) -> None:
+    client = CLIENT.get()
+    formatter = FORMATTER.get()
+    store = SESSION_STORE.get()
+    image = store.current_image
+    uuid = resolve_image(client, image)
+    if args.path is not None:
+        path = store.resolve_path(args.path)
+    else:
+        path = store.get_cwd() or "/"
+
+    if isinstance(formatter, DefaultFormatter):
+        resp = client.get(
+            f"/v1/inspect/{uuid}/list",
+            params={"path": path, "text": "1"},
+        )
+        sys.stdout.write(resp.read().decode())
+        return
+
+    cache_key = (uuid, f"list:{path}")
+    cached = store.cache.get(cache_key)
+    if cached is not None:
+        data = cast(dict[str, Any], cached)
+    else:
+        resp = client.get(f"/v1/inspect/{uuid}/list", params={"path": path})
+        data = json.loads(resp.read())
+        store.cache[cache_key] = data
+    for f in data["files"]:
+        if f.get("is_dir"):
+            ftype = "d"
+        elif f.get("is_symlink"):
+            ftype = "l"
+        else:
+            ftype = "-"
+        formatter(
+            path=f["path"],
+            size=f["size"],
+            mode=format(f["mode"], "o"),
+            owner=f.get("owner", f.get("uid", "")),
+            group=f.get("group", f.get("gid", "")),
+            mtime=datetime.fromtimestamp(f["mtime"], tz=timezone.utc),
+            type=ftype,
+        )

contree_cli/cli/ps.py

@@ -0,0 +1,120 @@
+"""List operations (running and completed instances, image imports).
+
+By default shows only active operations (PENDING, ASSIGNED, EXECUTING).
+Use -a/--all to include completed ones, or -S/--status to filter by a
+specific status. Use -K/--kind to filter by operation type.
+
+Use -q/--quiet to print only UUIDs, useful for scripting.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+from dataclasses import dataclass
+from datetime import timedelta
+
+from contree_cli import CLIENT, FORMATTER, ArgumentsProtocol, SetupResult
+from contree_cli.types import parse_datetime
+
+logger = logging.getLogger(__name__)
+
+PAGE_SIZE = 100
+ACTIVE_STATUSES = frozenset({"PENDING", "ASSIGNED", "EXECUTING"})
+
+
+@dataclass(frozen=True)
+class PsArgs(ArgumentsProtocol):
+    quiet: bool = False
+    all: bool = False
+    status: str | None = None
+    kind: str | None = None
+    since: str | None = None
+    until: str | None = None
+
+    @classmethod
+    def from_args(cls, ns: argparse.Namespace) -> PsArgs:
+        return cls(
+            quiet=ns.quiet,
+            all=getattr(ns, "all", False),
+            status=ns.status,
+            kind=ns.kind,
+            since=ns.since,
+            until=ns.until,
+        )
+
+
+def setup_parser(p: argparse.ArgumentParser) -> SetupResult:
+    p.add_argument(
+        "-q", "--quiet", action="store_true",
+        help="Only show UUIDs, useful for scripting",
+    )
+    p.add_argument(
+        "-a", "--all", action="store_true",
+        help="Show all operations (default: active only)",
+    )
+    p.add_argument(
+        "-S", "--status",
+        choices=(
+            "PENDING", "ASSIGNED", "EXECUTING",
+            "SUCCESS", "FAILED", "CANCELLED",
+        ),
+        help="Filter by status",
+    )
+    p.add_argument(
+        "-K", "--kind",
+        choices=("image_import", "instance"),
+        help="Filter by operation kind",
+    )
+    p.add_argument("--since", help="Show operations after date/time or interval")
+    p.add_argument("--until", help="Show operations before date/time or interval")
+    return cmd_ps, PsArgs
+
+
+def cmd_ps(args: PsArgs) -> None:
+    client = CLIENT.get()
+    formatter = FORMATTER.get()
+
+    # When neither --all nor --status is given, show only active operations.
+    filter_active = not args.all and args.status is None
+
+    base_params: dict[str, str] = {"limit": str(PAGE_SIZE)}
+    if args.status is not None:
+        base_params["status"] = args.status
+    if args.kind is not None:
+        base_params["kind"] = args.kind
+    if args.since is not None:
+        base_params["since"] = args.since
+    if args.until is not None:
+        base_params["until"] = args.until
+
+    offset = 0
+    while True:
+        params = {**base_params, "offset": str(offset)}
+        resp = client.get("/v1/operations", params=params)
+        operations = json.loads(resp.read())
+        if not operations:
+            break
+        for op in operations:
+            if filter_active and op["status"] not in ACTIVE_STATUSES:
+                continue
+            if args.quiet:
+                print(op["uuid"])
+            else:
+                created_at = parse_datetime(op["created_at"])
+                duration = (
+                    timedelta(seconds=op["duration"])
+                    if op.get("duration") is not None
+                    else None
+                )
+                formatter(
+                    uuid=op["uuid"],
+                    status=op["status"],
+                    kind=op["kind"],
+                    created_at=created_at,
+                    duration=duration,
+                    error=op.get("error") or "",
+                )
+        if len(operations) < PAGE_SIZE:
+            break
+        offset += len(operations)