margo-tooling 0.5.1__py3-none-any.whl

margo_tooling-0.5.1.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.5
+Name: margo-tooling
+Version: 0.5.1
+Summary: Developer CLI for building and publishing Margo application packages
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: dynaconf>=3.2.10
+Requires-Dist: jinja2>=3.1
+Requires-Dist: oras>=0.2.28
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=14.0.0
+Requires-Dist: semver>=3.0.4
+Requires-Dist: typer>=0.15.4

margo_tooling-0.5.1.dist-info/RECORD

@@ -0,0 +1,34 @@
+margot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+margot/config.py,sha256=cc_jRQN-T-UyfHjGJYC_buMqq2DLfRlw0A5r--4r3wY,2283
+margot/console.py,sha256=27TpwxURRKOBtQaWiBAXyfPVEfRGu9QwFO8N8BW82vg,4662
+margot/main.py,sha256=OVaLVVieWVcnlGOTAzmYCt4Pp5MmfxHhdW2DntRiWDo,835
+margot/commands/__init__.py,sha256=US6hzhLZfbYC00Po2aaVIgGs5rg1L71MbpFDKd9KMk8,40
+margot/commands/auth.py,sha256=fmsVbmrR2IQHYpZhng92doOg4qcclgXmQhiYzj57SFw,3982
+margot/commands/build.py,sha256=Toe8XDgoX1sXq3tnrLTm6h31P-L1at5kgFMSg_M9Xxw,3012
+margot/commands/fetch.py,sha256=_i8X-p5tylIsJ7p5AXISkrDag4S3fG7KhVNJyuvyUSA,652
+margot/commands/global_options.py,sha256=punmdJAxmRZNZIMPONIgQ5LvSg1rCwJhVwwCHmKbz8A,1001
+margot/commands/pull.py,sha256=-GOyEr4gC_UrD9MWUnP49oNI0urTN0FuDYQ2eNGDU5o,2032
+margot/commands/push.py,sha256=KUIN4n6acxobsamkNhkeeethXw8jjAp4W6o7EY_ymwM,3156
+margot/commands/version.py,sha256=aFI7B8xZ0QaGYNpMKkitTBxk7xBdEpw4CopxKX3ad0g,321
+margot/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+margot/domain/auth.py,sha256=OqNIj2sT7eSldi-y03VlcQvKTE45ufocQn2izzJx2W0,2575
+margot/domain/layers.py,sha256=9UNBjJx7srV0YC-c3RNO7cromGL1JWSdBEXpzh6HIdk,3392
+margot/domain/metadata.py,sha256=s-FYX8W2ArgwqC53odMaBDb6RvoLGJ71hly4WIlqo4c,8476
+margot/domain/models.py,sha256=lqeOTMjsePoCGRWiVgkf1iRgH_MBs9CsaMXLmv1xh58,1563
+margot/domain/tags.py,sha256=P37QKV7qsK6X-8KD-2L7WmrNXU5owrAavoiJJbZUjy4,1742
+margot/domain/uri.py,sha256=lMsAlErSq48fgQ94oLcEyW1KU4Z2Fr7X9gAHYpDxiUM,2214
+margot/infra/__init__.py,sha256=SWwiLcKZaATuZs2Lz1Xi2Cu9hJ1ErxgKt1q8z2q3P6o,33
+margot/infra/credentials.py,sha256=T1YJCU_vdl97jHlR45EJo01ONgNYa2VUEqxLimFayAM,6754
+margot/infra/filesystem.py,sha256=8Ji7YqS0p8qepeI0nJoQzNUfqWnnVUAgJGNgWCiCwTU,4010
+margot/infra/oci.py,sha256=TCQQ4M9NV9Vgwcnygn38D70fuEhQqZ2Oxoe0S10pWlQ,13071
+margot/services/__init__.py,sha256=LP0milclAyzZZ-rCaOvHbjf98gAxTnaKLU4C-pJ7f6s,52
+margot/services/auth.py,sha256=RHdKnO_6z7AH3NdXNPQPIdw_Ynf2nKVl0jslNB0tEuQ,3361
+margot/services/build.py,sha256=1SUxdBSTf_QmVsuZSRk7X2h46Q7icH5-I3MgmFrprHU,10578
+margot/services/fetch.py,sha256=aRkvQ9K4f5b_iN2UZPrkcZBe405mMWyffCdDzmSS_Yk,976
+margot/services/pull.py,sha256=4lmc53-Tttl5iIpBxFm0grU_G8Xmql8IvHAizZDfRjs,6546
+margot/services/push.py,sha256=JtqioOvzsb79Hwcm4cT4ZV47S4YV_pHkbSe-kL6EBXg,13084
+margo_tooling-0.5.1.dist-info/METADATA,sha256=_Lq-410NYg_KDOTcUMReWR-uNSvkaerP9WGby2aPtgA,383
+margo_tooling-0.5.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+margo_tooling-0.5.1.dist-info/entry_points.txt,sha256=w7pbJv6-Ho6RfPeDqjkKmbrdpVvO8NPA88Bt6laCMq8,43
+margo_tooling-0.5.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+margo_tooling-0.5.1.dist-info/RECORD,,

margo_tooling-0.5.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

margo_tooling-0.5.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+margot = margot.main:app

margo_tooling-0.5.1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

margot/commands/__init__.py

@@ -0,0 +1 @@
+"""Commands layer: CLI entry points."""

margot/commands/auth.py

@@ -0,0 +1,117 @@
+"""Auth commands: manage OCI registry credentials."""
+
+from datetime import UTC, datetime
+import sys
+from typing import Annotated
+
+from rich.table import Table
+from typer import Argument, Option, Typer
+
+from margot import console
+from margot.services import auth as auth_service
+
+app = Typer(name="auth", help="Manage OCI registry credentials.", no_args_is_help=True)
+
+
+def _format_expiry(expires_at: datetime) -> str:
+    """Format time remaining until expiry as a human-readable string."""
+    remaining = expires_at - datetime.now(tz=UTC)
+    total_seconds = int(remaining.total_seconds())
+    if total_seconds <= 0:
+        return f"already expired ({expires_at.strftime('%Y-%m-%dT%H:%M:%SZ')})"
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes = remainder // 60
+    return f"{hours}h {minutes:02d}m (expires {expires_at.strftime('%Y-%m-%dT%H:%M:%SZ')})"
+
+
+_STATUS_COLORS = {"VALID": "green", "EXPIRING": "yellow", "EXPIRED": "red"}
+
+
+def _format_remaining(remaining_seconds: int) -> str:
+    """Format a remaining-time duration (in seconds) as a human-readable string."""
+    if remaining_seconds <= 0:
+        return "expired"
+    hours, remainder = divmod(remaining_seconds, 3600)
+    minutes = remainder // 60
+    return f"{hours}h {minutes:02d}m"
+
+
+@app.command()
+def login(
+    registry: Annotated[str, Argument(help="Registry hostname (e.g. public.ecr.aws).")],
+    username: Annotated[str | None, Option("--username", "-u", help="Username for authentication.")] = None,
+    password_stdin: Annotated[bool, Option("--password-stdin", help="Read password from stdin.")] = False,
+    expiry_hours: Annotated[
+        int | None,
+        Option(
+            "--expiry-hours",
+            help="Save credential expiry to credentials file. Provide the number of hours until expiry (e.g. 12 for ECR).",
+        ),
+    ] = None,
+) -> None:
+    """Login to an OCI registry."""
+    if not username:
+        console.fatal("Username required. Use --username.")
+
+    if not password_stdin:
+        console.fatal("Password required. Use --password-stdin.")
+
+    password = sys.stdin.read().strip()
+    if not password:
+        console.fatal("Empty password received from stdin.")
+
+    try:
+        expires_at = auth_service.login(
+            registry=registry,
+            username=username,
+            password=password,
+            expiry_hours=expiry_hours,
+        )
+        console.success(f"Logged in to {registry}.")
+        if expires_at is not None:
+            console.success(f"Token expires in {_format_expiry(expires_at)}")
+    except Exception as e:  # noqa: BLE001
+        console.fatal(f"Login failed: {e}")
+
+
+@app.command()
+def logout(
+    registry: Annotated[str, Argument(help="Registry hostname (e.g. public.ecr.aws).")],
+) -> None:
+    """Logout from an OCI registry."""
+    try:
+        auth_service.logout(registry=registry)
+        console.success(f"Logged out from {registry}.")
+    except Exception as e:  # noqa: BLE001
+        console.fatal(f"Logout failed: {e}")
+
+
+@app.command()
+def status() -> None:
+    """Show credential status for all tracked OCI registries."""
+    result = auth_service.auth_status()
+
+    if not result.tracked and not result.oras_only:
+        console.success("No credentials tracked.")
+        return
+
+    table = Table(title="Registry Credential Status")
+    table.add_column("Registry")
+    table.add_column("Expires At")
+    table.add_column("Remaining")
+    table.add_column("Status")
+
+    for entry in result.tracked:
+        color = _STATUS_COLORS.get(entry.status, "white")
+        remaining = _format_remaining(int(entry.remaining.total_seconds()))
+        table.add_row(
+            entry.hostname,
+            entry.expires_at.strftime("%Y-%m-%dT%H:%M:%SZ"),
+            remaining,
+            f"[{color}]{entry.status}[/{color}]",
+        )
+
+    for hostname in result.oras_only:
+        table.add_row(hostname, "-", "present but expiry unknown", "[cyan]UNKNOWN[/cyan]")
+
+    console.print_table(table)

margot/commands/build.py

@@ -0,0 +1,88 @@
+"""Build command: compile Margo application components locally."""
+
+from typing import Annotated
+
+from typer import Option
+
+from margot import console
+from margot.domain.models import BuildTarget, PackageType
+from margot.services import build as build_service
+
+
+def _resolve_types(types: list[str] | None) -> tuple[list[str], bool]:
+    """Validate and expand --type values. Returns (resolved_types, expanded_from_all)."""
+    if not types:
+        return ["margo", "compose", "quadlet"], True
+
+    valid_types = ("margo", "compose", "quadlet", "all")
+    for t in types:
+        if t not in valid_types:
+            console.fatal(f"invalid --type '{t}'. Must be one of: margo, compose, quadlet, all")
+
+    if "all" in types:
+        return ["margo", "compose", "quadlet"], True
+
+    # Deduplicate preserving order
+    seen: set[str] = set()
+    resolved: list[str] = []
+    for t in types:
+        if t not in seen:
+            resolved.append(t)
+            seen.add(t)
+    return resolved, False
+
+
+def _invoke_build(
+    t: str,
+    expanded_from_all: bool,
+    build_dir: str,
+    version: str | None,
+    variant: str | None,
+) -> list[BuildTarget]:
+    """Call build service for one type. Returns targets or [] if component is missing and expanded_from_all."""
+    package_type = PackageType(t)
+    try:
+        return build_service.build(
+            package_type,
+            project_dir=".",
+            build_dir=build_dir,
+            version_override=version,
+            variant=variant,
+        )
+    except ValueError as e:
+        if expanded_from_all and "not defined in margo.yaml" in str(e):
+            console.info(f"Skipping {t}: not defined in margo.yaml")
+            return []
+        raise
+
+
+def build_cmd(
+    types: Annotated[
+        list[str] | None,
+        Option("--type", "-t", help="Package type(s) to build (margo|compose|quadlet|all). Repeatable."),
+    ] = None,
+    version: str | None = Option(None, "--version", "-v", help="Override version for all components."),
+    build_dir: str = Option(".dist", "--build-dir", help="Output directory for built artifacts."),
+    variant: str | None = Option(None, "--variant", help="Build a specific variant (compose/quadlet only)."),
+) -> None:
+    """Build Margo application package types locally."""
+    resolved, expanded_from_all = _resolve_types(types)
+
+    all_targets: list[BuildTarget] = []
+    try:
+        for t in resolved:
+            all_targets.extend(_invoke_build(t, expanded_from_all, build_dir, version, variant))
+
+        if all_targets:
+            for target in all_targets:
+                if target.variant_name:
+                    console.success(f"Built ({target.variant_name}): {target.artifact_path}")
+                else:
+                    console.success(f"Built: {target.artifact_path}")
+        else:
+            console.warning("Nothing was built.")
+
+    except ValueError as e:
+        console.fatal(str(e))
+    except Exception as e:  # noqa: BLE001
+        console.fatal(f"Build failed: {e}")

margot/commands/fetch.py

@@ -0,0 +1,22 @@
+"""Fetch command: retrieve and display OCI artifact manifest."""
+
+from typing import Any
+
+from margot import console
+from margot.services import fetch as fetch_service
+
+
+def fetch(uri: str) -> None:
+    """
+    Fetch and display the manifest of an OCI artifact.
+
+    Args:
+        uri: Full OCI reference (e.g. public.ecr.aws/g2n4p2m7/margo:1.0.0)
+    """
+    try:
+        manifest: dict[str, Any] = fetch_service.fetch_manifest(uri)
+        console.print_json(manifest)
+    except ValueError as e:
+        console.fatal(f"Error fetching manifest: {e}")
+    except Exception as e:  # noqa: BLE001
+        console.fatal(f"Error fetching manifest: {e}")

margot/commands/global_options.py

@@ -0,0 +1,29 @@
+"""Global CLI options: version, verbose, and debug flags."""
+
+from typer import Exit, Option, echo
+
+from margot.commands.version import get_version
+from margot.console import set_debug, set_verbose
+
+
+def global_options(
+    version_flag: bool = Option(False, "--version", "-V", help="Print version and exit.", is_eager=True),
+    verbose: bool = Option(False, "--verbose", "-v", help="Enable verbose output (step-level info)."),
+    debug: bool = Option(False, "--debug", "-d", help="Enable debug output (infra-level detail, implies --verbose)."),
+) -> None:
+    """Register global CLI options.
+
+    Handles version output and sets verbosity flags for the application.
+    Called once at startup via app.callback().
+    """
+    if debug:
+        set_debug(True)
+    elif verbose:
+        set_verbose(True)
+    else:
+        set_debug(False)
+        set_verbose(False)
+
+    if version_flag:
+        echo(f"margot {get_version()}")
+        raise Exit()  # noqa: RSE102 - Exit class must be instantiated

margot/commands/pull.py

@@ -0,0 +1,56 @@
+"""Pull command: retrieve OCI artifact layers to a local directory."""
+
+from typing import Annotated
+
+from typer import Argument, Option
+
+from margot import console
+from margot.domain.models import PackageType
+from margot.services import pull as pull_service
+
+_VALID_FORCE_TYPES = ("margo", "compose", "quadlet")
+
+
+def pull(
+    uri: str = Argument(..., help="Full OCI reference (e.g. public.ecr.aws/g2n4p2m7/margo:1.0.0)"),
+    output: str = Option(".", "--output", "-o", help="Output directory (default: current directory)."),
+    force: bool = Option(
+        False, "--force", "-f", help="Bypass SemVer gate, malicious annotation checks, and allow non-standard artifact types."
+    ),
+    force_type: Annotated[
+        str | None, Option("--force-type", help="Force artifact type interpretation (margo|compose|quadlet).")
+    ] = None,
+) -> None:
+    """
+    Pull OCI artifact layers to a local directory.
+
+    URI is the full OCI reference: registry/repository:tag
+    """
+    resolved_force_type: PackageType | None = None
+
+    if force_type is not None:
+        if force_type not in _VALID_FORCE_TYPES:
+            console.fatal(f"invalid --force-type '{force_type}'. Must be one of: {', '.join(_VALID_FORCE_TYPES)}")
+        resolved_force_type = PackageType(force_type)
+
+    if resolved_force_type is not None and not force:
+        force = True
+        console.warning("--force-type implies --force. Safety checks bypassed.")
+    elif force and resolved_force_type is None:
+        console.warning("--force is active. Safety checks bypassed.")
+
+    try:
+        paths = pull_service.pull_artifact(
+            uri,
+            outdir=output,
+            force=force,
+            force_type=resolved_force_type,
+        )
+        for path in paths:
+            console.success(f"Pulled: {path}")
+        if not paths:
+            console.warning("No layers pulled.")
+    except ValueError as e:
+        console.fatal(str(e))
+    except Exception as e:  # noqa: BLE001
+        console.fatal(f"Error pulling artifact: {e}")

margot/commands/push.py

@@ -0,0 +1,91 @@
+"""Push command: push built Margo artifacts to OCI registries."""
+
+from typing import Annotated
+
+from typer import Option
+
+from margot import console
+from margot.domain.models import BuildTarget, PackageType
+from margot.services import push as push_service
+
+
+def _resolve_types(types: list[str] | None) -> tuple[list[str], bool]:
+    """Validate and expand --type values. Returns (resolved_types, expanded_from_all)."""
+    if not types:
+        return ["margo", "compose", "quadlet"], True
+
+    valid_types = ("margo", "compose", "quadlet", "all")
+    for t in types:
+        if t not in valid_types:
+            console.fatal(f"invalid --type '{t}'. Must be one of: margo, compose, quadlet, all")
+
+    if "all" in types:
+        return ["margo", "compose", "quadlet"], True
+
+    # Deduplicate preserving order
+    seen: set[str] = set()
+    resolved: list[str] = []
+    for t in types:
+        if t not in seen:
+            resolved.append(t)
+            seen.add(t)
+    return resolved, False
+
+
+def _invoke_push(  # noqa: PLR0913
+    t: str,
+    expanded_from_all: bool,
+    build_dir: str,
+    registry: str | None,
+    repository: str | None,
+    variant: str | None,
+) -> list[BuildTarget]:
+    """Call push service for one type. Returns targets or [] if component is missing and expanded_from_all."""
+    package_type = PackageType(t)
+    try:
+        return push_service.push(
+            package_type,
+            project_dir=".",
+            build_dir=build_dir,
+            registry=registry,
+            repository=repository,
+            variant=variant,
+        )
+    except ValueError as e:
+        if expanded_from_all and "not defined in margo.yaml" in str(e):
+            console.info(f"Skipping {t}: not defined in margo.yaml")
+            return []
+        raise
+
+
+def push_cmd(
+    types: Annotated[
+        list[str] | None,
+        Option("--type", "-t", help="Package type(s) to push (margo|compose|quadlet|all). Repeatable."),
+    ] = None,
+    registry: str | None = Option(None, "--registry", help="OCI registry base URL."),
+    repository: str | None = Option(None, "--repository", help="Repository path."),
+    build_dir: str = Option(".dist", "--build-dir", help="Directory containing built artifacts."),
+    variant: str | None = Option(None, "--variant", help="Push a specific variant (compose/quadlet only)."),
+) -> None:
+    """Push built Margo application artifacts to an OCI registry."""
+    resolved, expanded_from_all = _resolve_types(types)
+
+    all_targets: list[BuildTarget] = []
+    try:
+        for t in resolved:
+            all_targets.extend(_invoke_push(t, expanded_from_all, build_dir, registry, repository, variant))
+
+        if all_targets:
+            for target in all_targets:
+                if target.variant_name:
+                    console.success(f"Pushed ({target.variant_name}): {target.version}")
+                else:
+                    console.success(f"Pushed: {target.version}")
+        else:
+            console.warning("Nothing was pushed.")
+
+    except ValueError as e:
+        console.fatal(str(e))
+    except Exception as e:  # noqa: BLE001
+        console.fatal(f"Push failed: {e}")