opensandbox-cli 0.1.0.dev1__py3-none-any.whl

opensandbox_cli/commands/devops.py

@@ -0,0 +1,99 @@
+# Copyright 2026 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Experimental DevOps diagnostics commands: logs, inspect, events, summary."""
+
+from __future__ import annotations
+
+import click
+
+from opensandbox_cli.client import ClientContext
+from opensandbox_cli.utils import handle_errors
+
+
+def _fetch_plain_text(obj: ClientContext, sandbox_id: str, endpoint: str, params: dict | None = None) -> str:
+    """Fetch a diagnostics endpoint and return the plain-text body."""
+    sandbox_id = obj.resolve_sandbox_id(sandbox_id)
+    client = obj.get_devops_client()
+    resp = client.get(f"/sandboxes/{sandbox_id}/diagnostics/{endpoint}", params=params)
+    if resp.status_code == 404:
+        raise click.ClickException(f"Sandbox '{sandbox_id}' not found.")
+    resp.raise_for_status()
+    return resp.text
+
+
+@click.group("devops", invoke_without_command=True)
+@click.pass_context
+def devops_group(ctx: click.Context) -> None:
+    """Experimental diagnostics for sandbox troubleshooting."""
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+# ---- logs ----------------------------------------------------------------
+
+@devops_group.command("logs")
+@click.argument("sandbox_id")
+@click.option("--tail", "-n", type=int, default=100, show_default=True, help="Number of trailing log lines.")
+@click.option("--since", "-s", default=None, help="Only logs newer than this duration (e.g. 10m, 1h).")
+@click.pass_obj
+@handle_errors
+def devops_logs(obj: ClientContext, sandbox_id: str, tail: int, since: str | None) -> None:
+    """Retrieve container logs for a sandbox."""
+    params: dict = {"tail": tail}
+    if since:
+        params["since"] = since
+    text = _fetch_plain_text(obj, sandbox_id, "logs", params=params)
+    click.echo(text)
+
+
+# ---- inspect -------------------------------------------------------------
+
+@devops_group.command("inspect")
+@click.argument("sandbox_id")
+@click.pass_obj
+@handle_errors
+def devops_inspect(obj: ClientContext, sandbox_id: str) -> None:
+    """Retrieve detailed container/pod inspection info."""
+    text = _fetch_plain_text(obj, sandbox_id, "inspect")
+    click.echo(text)
+
+
+# ---- events --------------------------------------------------------------
+
+@devops_group.command("events")
+@click.argument("sandbox_id")
+@click.option("--limit", "-l", type=int, default=50, show_default=True, help="Maximum number of events.")
+@click.pass_obj
+@handle_errors
+def devops_events(obj: ClientContext, sandbox_id: str, limit: int) -> None:
+    """Retrieve events related to a sandbox."""
+    params: dict = {"limit": limit}
+    text = _fetch_plain_text(obj, sandbox_id, "events", params=params)
+    click.echo(text)
+
+
+# ---- summary -------------------------------------------------------------
+
+@devops_group.command("summary")
+@click.argument("sandbox_id")
+@click.option("--tail", "-n", type=int, default=50, show_default=True, help="Number of trailing log lines.")
+@click.option("--event-limit", type=int, default=20, show_default=True, help="Maximum number of events.")
+@click.pass_obj
+@handle_errors
+def devops_summary(obj: ClientContext, sandbox_id: str, tail: int, event_limit: int) -> None:
+    """One-shot diagnostics: inspect + events + logs combined."""
+    params: dict = {"tail": tail, "event_limit": event_limit}
+    text = _fetch_plain_text(obj, sandbox_id, "summary", params=params)
+    click.echo(text)

opensandbox_cli/commands/egress.py

@@ -0,0 +1,89 @@
+# Copyright 2026 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Runtime egress policy commands."""
+
+from __future__ import annotations
+
+import click
+from opensandbox.models.sandboxes import NetworkRule
+
+from opensandbox_cli.client import ClientContext
+from opensandbox_cli.utils import handle_errors
+
+
+def _parse_rule(value: str) -> NetworkRule:
+    """Parse ACTION=TARGET into a NetworkRule."""
+    action, sep, target = value.partition("=")
+    if not sep:
+        raise click.BadParameter(
+            f"Invalid rule '{value}'. Use ACTION=TARGET, for example allow=pypi.org."
+        )
+    action = action.strip().lower()
+    target = target.strip()
+    if action not in ("allow", "deny"):
+        raise click.BadParameter(
+            f"Invalid rule action '{action}'. Use allow or deny."
+        )
+    return NetworkRule(action=action, target=target)
+
+
+@click.group("egress", invoke_without_command=True)
+@click.pass_context
+def egress_group(ctx: click.Context) -> None:
+    """Manage runtime egress policy for a sandbox."""
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+@egress_group.command("get")
+@click.argument("sandbox_id")
+@click.pass_obj
+@handle_errors
+def egress_get(obj: ClientContext, sandbox_id: str) -> None:
+    """Get the current egress policy."""
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        policy = sandbox.get_egress_policy()
+        obj.output.print_model(policy, title="Egress Policy")
+    finally:
+        sandbox.close()
+
+
+@egress_group.command("patch")
+@click.argument("sandbox_id")
+@click.option(
+    "--rule",
+    "rules",
+    multiple=True,
+    required=True,
+    help="Patch rule in ACTION=TARGET form. Repeatable, e.g. --rule allow=pypi.org.",
+)
+@click.pass_obj
+@handle_errors
+def egress_patch(obj: ClientContext, sandbox_id: str, rules: tuple[str, ...]) -> None:
+    """Patch runtime egress rules with merge semantics."""
+    parsed_rules = [_parse_rule(rule) for rule in rules]
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        sandbox.patch_egress_rules(parsed_rules)
+        obj.output.success_panel(
+            {
+                "sandbox_id": sandbox.id,
+                "patched_rules": [rule.model_dump(mode="json") for rule in parsed_rules],
+            },
+            title="Egress Policy Patched",
+        )
+    finally:
+        sandbox.close()

opensandbox_cli/commands/file.py

@@ -0,0 +1,360 @@
+# Copyright 2026 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""File operation commands: cat, write, upload, download, rm, mv, mkdir, rmdir, search, info, chmod, replace."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from opensandbox_cli.client import ClientContext
+from opensandbox_cli.utils import handle_errors
+
+
+def _parse_permission_mode(mode: str) -> int:
+    """Parse a permission mode string into a base-10 integer."""
+    try:
+        return int(mode)
+    except ValueError as exc:
+        raise click.BadParameter(
+            f"Invalid permission mode '{mode}'. Use a base-10 integer like 644 or 755."
+        ) from exc
+
+
+@click.group("file", invoke_without_command=True)
+@click.pass_context
+def file_group(ctx: click.Context) -> None:
+    """📁 File operations on a sandbox."""
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+# ---- cat (read) -----------------------------------------------------------
+
+@file_group.command("cat")
+@click.argument("sandbox_id")
+@click.argument("path")
+@click.option("--encoding", default="utf-8", help="File encoding.")
+@click.pass_obj
+@handle_errors
+def file_cat(obj: ClientContext, sandbox_id: str, path: str, encoding: str) -> None:
+    """Read a file from the sandbox."""
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        content = sandbox.files.read_file(path, encoding=encoding)
+        click.echo(content, nl=False)
+    finally:
+        sandbox.close()
+
+
+# ---- write ----------------------------------------------------------------
+
+@file_group.command("write")
+@click.argument("sandbox_id")
+@click.argument("path")
+@click.option("--content", "-c", default=None, help="Content to write. Reads from stdin if not provided.")
+@click.option("--encoding", default="utf-8", help="File encoding.")
+@click.option("--mode", default=None, help="File permission mode (e.g. 0644).")
+@click.option("--owner", default=None, help="File owner.")
+@click.option("--group", default=None, help="File group.")
+@click.pass_obj
+@handle_errors
+def file_write(
+    obj: ClientContext,
+    sandbox_id: str,
+    path: str,
+    content: str | None,
+    encoding: str,
+    mode: str | None,
+    owner: str | None,
+    group: str | None,
+) -> None:
+    """Write content to a file in the sandbox."""
+    file_content = content
+    if file_content is None:
+        if sys.stdin.isatty():
+            click.echo("Reading from stdin (Ctrl+D to finish):", err=True)
+        file_content = sys.stdin.read()
+
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        kwargs: dict = {"encoding": encoding}
+        if mode is not None:
+            kwargs["mode"] = _parse_permission_mode(mode)
+        if owner is not None:
+            kwargs["owner"] = owner
+        if group is not None:
+            kwargs["group"] = group
+        sandbox.files.write_file(path, file_content, **kwargs)
+        obj.output.success(f"Written: {path}")
+    finally:
+        sandbox.close()
+
+
+# ---- upload ---------------------------------------------------------------
+
+@file_group.command("upload")
+@click.argument("sandbox_id")
+@click.argument("local_path", type=click.Path(exists=True))
+@click.argument("remote_path")
+@click.pass_obj
+@handle_errors
+def file_upload(
+    obj: ClientContext, sandbox_id: str, local_path: str, remote_path: str
+) -> None:
+    """Upload a local file to the sandbox."""
+    data = Path(local_path).read_bytes()
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        sandbox.files.write_file(remote_path, data)
+        obj.output.success(f"Uploaded: {local_path} → {remote_path}")
+    finally:
+        sandbox.close()
+
+
+# ---- download -------------------------------------------------------------
+
+@file_group.command("download")
+@click.argument("sandbox_id")
+@click.argument("remote_path")
+@click.argument("local_path", type=click.Path())
+@click.pass_obj
+@handle_errors
+def file_download(
+    obj: ClientContext, sandbox_id: str, remote_path: str, local_path: str
+) -> None:
+    """Download a file from the sandbox to local disk."""
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        content = sandbox.files.read_bytes(remote_path)
+        Path(local_path).write_bytes(content)
+        obj.output.success(f"Downloaded: {remote_path} → {local_path}")
+    finally:
+        sandbox.close()
+
+
+# ---- rm (delete) ----------------------------------------------------------
+
+@file_group.command("rm")
+@click.argument("sandbox_id")
+@click.argument("paths", nargs=-1, required=True)
+@click.pass_obj
+@handle_errors
+def file_rm(obj: ClientContext, sandbox_id: str, paths: tuple[str, ...]) -> None:
+    """Delete files from the sandbox."""
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        sandbox.files.delete_files(list(paths))
+        for p in paths:
+            obj.output.success(f"Deleted: {p}")
+    finally:
+        sandbox.close()
+
+
+# ---- mv (move) ------------------------------------------------------------
+
+@file_group.command("mv")
+@click.argument("sandbox_id")
+@click.argument("source")
+@click.argument("destination")
+@click.pass_obj
+@handle_errors
+def file_mv(
+    obj: ClientContext, sandbox_id: str, source: str, destination: str
+) -> None:
+    """Move/rename a file in the sandbox."""
+    from opensandbox.models.filesystem import MoveEntry
+
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        sandbox.files.move_files([MoveEntry(source=source, destination=destination)])
+        obj.output.success(f"Moved: {source} → {destination}")
+    finally:
+        sandbox.close()
+
+
+# ---- mkdir ----------------------------------------------------------------
+
+@file_group.command("mkdir")
+@click.argument("sandbox_id")
+@click.argument("paths", nargs=-1, required=True)
+@click.option("--mode", default=None, help="Directory permission mode.")
+@click.option("--owner", default=None, help="Directory owner.")
+@click.option("--group", default=None, help="Directory group.")
+@click.pass_obj
+@handle_errors
+def file_mkdir(
+    obj: ClientContext,
+    sandbox_id: str,
+    paths: tuple[str, ...],
+    mode: str | None,
+    owner: str | None,
+    group: str | None,
+) -> None:
+    """Create directories in the sandbox."""
+    from opensandbox.models.filesystem import WriteEntry
+
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        entries = []
+        for p in paths:
+            kwargs: dict = {"path": p}
+            if mode is not None:
+                kwargs["mode"] = _parse_permission_mode(mode)
+            if owner is not None:
+                kwargs["owner"] = owner
+            if group is not None:
+                kwargs["group"] = group
+            entries.append(WriteEntry(**kwargs))
+        sandbox.files.create_directories(entries)
+        for p in paths:
+            obj.output.success(f"Created: {p}")
+    finally:
+        sandbox.close()
+
+
+# ---- rmdir ----------------------------------------------------------------
+
+@file_group.command("rmdir")
+@click.argument("sandbox_id")
+@click.argument("paths", nargs=-1, required=True)
+@click.pass_obj
+@handle_errors
+def file_rmdir(obj: ClientContext, sandbox_id: str, paths: tuple[str, ...]) -> None:
+    """Delete directories from the sandbox."""
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        sandbox.files.delete_directories(list(paths))
+        for p in paths:
+            obj.output.success(f"Removed: {p}")
+    finally:
+        sandbox.close()
+
+
+# ---- search ---------------------------------------------------------------
+
+@file_group.command("search")
+@click.argument("sandbox_id")
+@click.argument("path")
+@click.option("--pattern", "-p", required=True, help="Glob pattern to search for.")
+@click.pass_obj
+@handle_errors
+def file_search(
+    obj: ClientContext, sandbox_id: str, path: str, pattern: str
+) -> None:
+    """Search for files in the sandbox."""
+    from opensandbox.models.filesystem import SearchEntry
+
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        results = sandbox.files.search(SearchEntry(path=path, pattern=pattern))
+        if not results:
+            if obj.output.fmt in ("json", "yaml"):
+                obj.output.print_models([], columns=[])
+            else:
+                obj.output.info("No files found.")
+            return
+        if obj.output.fmt in ("json", "yaml"):
+            obj.output.print_models(results, columns=["path", "size", "mode", "owner", "modified_at"])
+        else:
+            obj.output.print_models(results, columns=["path", "size", "owner"], title="Search Results")
+    finally:
+        sandbox.close()
+
+
+# ---- info (stat) ----------------------------------------------------------
+
+@file_group.command("info")
+@click.argument("sandbox_id")
+@click.argument("paths", nargs=-1, required=True)
+@click.pass_obj
+@handle_errors
+def file_info(obj: ClientContext, sandbox_id: str, paths: tuple[str, ...]) -> None:
+    """Get file/directory info."""
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        info_map = sandbox.files.get_file_info(list(paths))
+        for path, entry in info_map.items():
+            obj.output.print_dict(
+                {"path": path, **entry.model_dump(mode="json")},
+                title=path,
+            )
+    finally:
+        sandbox.close()
+
+
+# ---- chmod ----------------------------------------------------------------
+
+@file_group.command("chmod")
+@click.argument("sandbox_id")
+@click.argument("path")
+@click.option("--mode", required=True, help="Permission mode (e.g. 0755).")
+@click.option("--owner", default=None, help="File owner.")
+@click.option("--group", default=None, help="File group.")
+@click.pass_obj
+@handle_errors
+def file_chmod(
+    obj: ClientContext,
+    sandbox_id: str,
+    path: str,
+    mode: str,
+    owner: str | None,
+    group: str | None,
+) -> None:
+    """Set file permissions."""
+    from opensandbox.models.filesystem import SetPermissionEntry
+
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        sandbox.files.set_permissions(
+            [
+                SetPermissionEntry(
+                    path=path,
+                    mode=_parse_permission_mode(mode),
+                    owner=owner,
+                    group=group,
+                )
+            ]
+        )
+        obj.output.success(f"Permissions set: {path}")
+    finally:
+        sandbox.close()
+
+
+# ---- replace --------------------------------------------------------------
+
+@file_group.command("replace")
+@click.argument("sandbox_id")
+@click.argument("path")
+@click.option("--old", required=True, help="Text to search for.")
+@click.option("--new", required=True, help="Replacement text.")
+@click.pass_obj
+@handle_errors
+def file_replace(
+    obj: ClientContext, sandbox_id: str, path: str, old: str, new: str
+) -> None:
+    """Replace content in a file."""
+    from opensandbox.models.filesystem import ContentReplaceEntry
+
+    sandbox = obj.connect_sandbox(sandbox_id)
+    try:
+        sandbox.files.replace_contents(
+            [ContentReplaceEntry(path=path, old_content=old, new_content=new)]
+        )
+        obj.output.success(f"Replaced in: {path}")
+    finally:
+        sandbox.close()