logion-cli 0.1.0__py3-none-any.whl

cli/commands/identity/_companion_source.py

@@ -0,0 +1,135 @@
+# SPDX-License-Identifier: MIT
+"""Resolve and materialize the companion bundle source.
+
+The companion step accepts three source shapes so the same code path
+works for a checked-out bundle directory, a downloaded release tarball
+(the real ``curl | sh`` installer fetches one), and the dev rig's
+``companion-bundle/`` directory that holds a single built tarball:
+
+- a directory containing ``SKILL.md`` — used as-is;
+- a ``*.tar.gz`` file — extracted on demand;
+- a directory holding exactly one
+  ``logion-marketplace-companion-*.tar.gz`` — that tarball is extracted.
+
+``materialize_bundle`` is a context manager so the extracted temp dir
+stays alive for the whole install and is cleaned up afterwards.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import os
+import tarfile
+import tempfile
+from collections.abc import Iterator
+from pathlib import Path
+
+from cli._local_state import get_home
+
+_COMPANION_TARBALL_GLOB = "logion-marketplace-companion-*.tar.gz"
+
+
+def _is_valid_source(path: Path) -> bool:
+    """A directory (validated downstream) or a ``*.tar.gz`` file."""
+    if path.is_dir():
+        return True
+    return path.is_file() and path.name.endswith(".tar.gz")
+
+
+def locate_bundle_source(args: argparse.Namespace) -> Path | None:
+    """Resolve the companion bundle source (a dir or a tarball).
+
+    Order: ``--companion-source`` flag →
+    ``$LOGION_COMPANION_BUNDLE_SOURCE`` env →
+    newest dir under ``$LOGION_HOME/companion-bundles/`` → None.
+
+    The returned path may be a bundle directory, a companion ``*.tar.gz``
+    file, or a directory holding exactly one companion tarball;
+    ``materialize_bundle`` normalizes all three to a bundle directory.
+    """
+    source = getattr(args, "companion_source", None)
+    if source is not None:
+        path = Path(source)
+        return path if _is_valid_source(path) else None
+
+    env_source = os.environ.get("LOGION_COMPANION_BUNDLE_SOURCE")
+    if env_source:
+        path = Path(env_source)
+        if _is_valid_source(path):
+            return path
+
+    bundles_root = get_home() / "companion-bundles"
+    if not bundles_root.is_dir():
+        return None
+
+    # Newest dir by mtime; skip entries that can't be stat'ed (perms,
+    # broken mounts, transient FS errors) so onboarding never crashes.
+    newest: tuple[float, Path] | None = None
+    for entry in bundles_root.iterdir():
+        try:
+            if not entry.is_dir():
+                continue
+            mtime = entry.stat().st_mtime
+        except OSError:
+            continue
+        if newest is None or mtime > newest[0]:
+            newest = (mtime, entry)
+    return newest[1] if newest else None
+
+
+def _find_companion_tarball(directory: Path) -> Path | None:
+    """Return the single companion tarball in *directory*, else None."""
+    try:
+        tarballs = sorted(directory.glob(_COMPANION_TARBALL_GLOB))
+    except OSError:
+        return None
+    return tarballs[0] if len(tarballs) == 1 else None
+
+
+def _bundle_root(extracted: Path) -> Path:
+    """Return the dir holding ``SKILL.md`` after extraction.
+
+    ``package_skill.py`` builds tarballs under a top-level
+    ``logion-marketplace-companion-<version>/`` prefix, so descend into a
+    lone prefix subdir when ``SKILL.md`` isn't at the extraction root.
+    """
+    if (extracted / "SKILL.md").is_file():
+        return extracted
+    subdirs = [p for p in extracted.iterdir() if p.is_dir()]
+    if len(subdirs) == 1 and (subdirs[0] / "SKILL.md").is_file():
+        return subdirs[0]
+    return extracted
+
+
+def _tarball_for(source: Path) -> Path | None:
+    """Return the tarball to extract for *source*, or None for a dir."""
+    if source.is_file() and source.name.endswith(".tar.gz"):
+        return source
+    if source.is_dir() and not (source / "SKILL.md").is_file():
+        return _find_companion_tarball(source)
+    return None
+
+
+@contextlib.contextmanager
+def materialize_bundle(source: Path) -> Iterator[Path]:
+    """Yield a bundle directory for *source*, extracting a tarball if needed.
+
+    A directory that already contains ``SKILL.md`` is yielded unchanged.
+    A tarball (or a directory holding exactly one companion tarball) is
+    extracted into a temporary directory — using ``tarfile``'s ``data``
+    filter for path-traversal safety — and the resolved bundle root is
+    yielded. The temp dir is removed when the context exits.
+    """
+    tarball = _tarball_for(source)
+    if tarball is None:
+        # Plain directory; the install validates SKILL.md downstream and
+        # emits a clear error if it's missing.
+        yield source
+        return
+
+    with tempfile.TemporaryDirectory(prefix="logion-companion-") as tmp:
+        dest = Path(tmp)
+        with tarfile.open(tarball, "r:gz") as tf:
+            tf.extractall(dest, filter="data")
+        yield _bundle_root(dest)

cli/commands/identity/_harness_select.py

@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: MIT
+"""Harness selection for ``identity onboarding``.
+
+Resolves which harness adapters the onboarding flow should configure
+(auto-review grant + companion install). The same selection drives both
+steps so the two never diverge.
+
+Resolution order:
+- explicit ``--harness`` (repeatable) → exactly those adapters, no prompt;
+- a TTY with at least one detected harness → an interactive multi-select
+  (nothing pre-selected — the user picks);
+- otherwise (non-interactive, or no harness detected) → every detected
+  harness, preserving the prior non-interactive behaviour.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from cli._errors import print_err
+from cli._harness import detect_present, get_adapter
+from cli._harness.base import HarnessAdapter
+
+
+def _parse_indices(answer: str, count: int) -> list[int] | None:
+    """Parse ``"1,3"`` / ``"1 3"`` into 0-based indices, or None if bad."""
+    tokens = answer.replace(",", " ").split()
+    out: list[int] = []
+    for tok in tokens:
+        if not tok.isdigit():
+            return None
+        idx = int(tok) - 1
+        if idx < 0 or idx >= count:
+            return None
+        if idx not in out:
+            out.append(idx)
+    return out
+
+
+def _prompt_selection(detected: list[HarnessAdapter]) -> list[HarnessAdapter]:
+    """Interactively pick a subset of *detected*; empty input → none."""
+    print_err("\nDetected agent harnesses:")
+    for i, adapter in enumerate(detected, start=1):
+        print_err(f"  {i}. {adapter.name}")
+    while True:
+        # Prompt on stderr (not via input()'s stdout prompt) so --json
+        # output on stdout stays machine-readable.
+        print_err("Select harness(es) to set up [e.g. 1,3; empty to skip]: ")
+        try:
+            answer = input().strip()
+        except EOFError:
+            return []
+        if not answer:
+            return []
+        indices = _parse_indices(answer, len(detected))
+        if indices is None:
+            print_err("Enter numbers from the list, e.g. 1,3.")
+            continue
+        return [detected[i] for i in indices]
+
+
+def select_harnesses(args: argparse.Namespace) -> list[HarnessAdapter]:
+    """Resolve the harness adapters to configure during onboarding.
+
+    Returns the resolved adapters (possibly empty). An explicit but
+    unknown ``--harness`` is validated earlier by
+    ``validate_explicit_harness``; unknown names are dropped here so the
+    caller never crashes.
+    """
+    requested = getattr(args, "harness", None)
+    if requested:
+        return [
+            adapter
+            for name in requested
+            if (adapter := get_adapter(name)) is not None
+        ]
+
+    detected = detect_present()
+    if not detected:
+        return []
+    if not sys.stdin.isatty():
+        # Non-interactive: keep configuring every detected harness.
+        return detected
+    return _prompt_selection(detected)

cli/commands/identity/_onboarding_helpers.py

@@ -0,0 +1,168 @@
+# SPDX-License-Identifier: MIT
+"""Orchestration helpers for ``identity onboarding``.
+
+Extracted from ``onboarding.py`` to keep that module under the CLI's
+per-file source-size budget (250 lines).  These functions coordinate
+the companion and harness-validation steps; they are not part of the
+``_companion`` module because they are onboarding-flow glue, not
+companion-install primitives.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from cli._errors import print_err
+from cli._harness import adapter_names, get_adapter
+from cli._harness.base import HarnessAdapter
+
+from ._companion import (
+    COMPANION_COURSE_ID,
+    CompanionInstallError,
+    CompanionNotFoundError,
+    CompanionResult,
+    install_companion,
+)
+
+
+def empty_companion_summary() -> dict[str, object]:
+    return {
+        "installed": False,
+        "skill_dir": None,
+        "course_id": None,
+        "version_id": None,
+        "already": False,
+    }
+
+
+def validate_explicit_harness(args: argparse.Namespace) -> int | None:
+    """Return an exit code if any explicit ``--harness`` is invalid.
+
+    ``--harness`` is repeatable, so every requested name is validated.
+    Validated whenever ``--harness`` is set, *regardless of*
+    ``--agent-dir``: ``--agent-dir`` only overrides the companion
+    target, but ``--harness`` still drives the autopost grant and the
+    harness selection.
+    """
+    requested = getattr(args, "harness", None) or []
+    for name in requested:
+        if get_adapter(name) is None:
+            print_err(
+                f"Error: unknown harness '{name}'. "
+                f"Supported: {', '.join(adapter_names())}."
+            )
+            return 2
+    return None
+
+
+def run_companion_step(
+    args: argparse.Namespace,
+    adapters: list[HarnessAdapter],
+) -> tuple[dict[str, object], int | None]:
+    """Run the companion install step.
+
+    Returns ``(summary_dict, exit_code_or_none)``.  A non-None exit
+    code means the caller should return it immediately.
+
+    *adapters* is the harness selection resolved once by
+    ``select_harnesses``; the companion is installed into each. An
+    explicit ``--agent-dir`` overrides the target to that single skill
+    dir (a ``CustomPathHarness``), independent of the selection.
+    """
+    if getattr(args, "no_companion", False):
+        return empty_companion_summary(), None
+
+    targets = companion_targets(args, adapters)
+
+    if not targets:
+        print_err(
+            "No agent harness selected, so the companion bundle was not "
+            "installed. Re-run with --harness <name> or --agent-dir <path>."
+        )
+        return empty_companion_summary(), None
+    adapters = targets
+
+    # Install the companion into each resolved adapter.  The canonical
+    # install (manifest + content hash) happens once per (course_id,
+    # version_id); subsequent adapters just get a symlink.
+    summaries: list[dict[str, object]] = []
+    for adapter in adapters:
+        try:
+            companion = install_companion(args, adapter)
+        except CompanionNotFoundError as exc:
+            print_err(
+                f"Warning: companion not installed for {adapter.name}: {exc}"
+            )
+            companion = CompanionResult(
+                installed=False,
+                skill_dir=None,
+                course_id=None,
+                version_id=None,
+                already=False,
+            )
+        except CompanionInstallError as exc:
+            print_err(
+                f"Error: companion install failed for {adapter.name}: {exc}"
+            )
+            return empty_companion_summary(), 2
+        summaries.append(companion.to_dict())
+
+    # The JSON summary mirrors the single-harness shape for backwards
+    # compatibility: the first adapter's result, with a ``harnesses``
+    # list when more than one was targeted.
+    result = dict(summaries[0])
+    if len(summaries) > 1:
+        result["harnesses"] = summaries
+    return result, None
+
+
+def ensure_symlink(
+    adapter: HarnessAdapter,
+    install_dest: Path,
+    skill_name: str | None = None,
+) -> None:
+    """Symlink ``install_dest`` into ``adapter.skill_dir()``.
+
+    Uses the existing ``create_symlink`` helper so we share the same
+    replace-prior-link/refuse-real-directory behaviour as
+    ``logion skills install --symlink-dir``.
+
+    A symlink failure is **non-fatal and never raises**: it is surfaced
+    as a warning on stderr (mirroring ``apply_post_install_symlink``),
+    so onboarding does not crash — or corrupt ``--json`` with a
+    traceback — when the target is a real directory or otherwise
+    unwritable.  The canonical install under ``$LOGION_HOME/installed/``
+    is valid regardless.
+    """
+    from cli.commands.skills._agent_symlink import create_symlink
+
+    skill_name = skill_name or COMPANION_COURSE_ID
+    target_skill_dir = adapter.skill_dir()
+    try:
+        create_symlink(target_skill_dir, skill_name, install_dest)
+    except FileExistsError as exc:
+        print_err(f"Warning: companion symlink skipped: {exc}")
+    except OSError as exc:
+        print_err(
+            f"Warning: companion symlink failed ({exc}); "
+            "canonical install is fine."
+        )
+
+
+def companion_targets(
+    args: argparse.Namespace,
+    adapters: list[HarnessAdapter],
+) -> list[HarnessAdapter]:
+    """Resolve the adapter(s) for the companion step.
+
+    ``--agent-dir`` overrides the resolved selection with a single
+    ``CustomPathHarness``; otherwise the shared *adapters* selection is
+    used as-is.
+    """
+    agent_dir = getattr(args, "agent_dir", None)
+    if agent_dir:
+        from cli._harness.custom import CustomPathHarness
+
+        return [CustomPathHarness(Path(agent_dir).expanduser())]
+    return adapters

cli/commands/identity/handlers.py

@@ -0,0 +1,173 @@
+# SPDX-License-Identifier: MIT
+"""Handlers for identity commands."""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import os
+import sys
+
+from cli._config import resolve_config_from_args
+from cli._context import make_client
+from cli._credentials import save_user_identity, stored_user_id
+from cli._errors import handle_error, print_err
+from cli._output import emit
+
+API_KEY_WARNING = (
+    "Important: save the API key now — it will not be shown again."
+)
+
+
+def _resolve_password(cli_value: str | None) -> str | None:
+    """Return the resolved password, or ``None`` on validation failure."""
+    if cli_value is not None:
+        if not cli_value.strip():
+            print_err("Error: --password must not be empty.")
+            return None
+        if cli_value != cli_value.strip():
+            print_err(
+                "Warning: --password has leading/trailing whitespace — "
+                "this is intentional, but may be a shell quoting mistake."
+            )
+        return cli_value
+    raw_env = os.environ.get("LOGION_PASSWORD")
+    if raw_env is not None:
+        if not raw_env.strip():
+            print_err("Error: LOGION_PASSWORD is set but empty/whitespace.")
+            return None
+        if raw_env != raw_env.strip():
+            print_err(
+                "Warning: LOGION_PASSWORD has leading/trailing whitespace — "
+                "this is intentional, but may be an environment setup mistake."
+            )
+        return raw_env
+    if sys.stdin.isatty():
+        password = getpass.getpass("Logion Password: ")
+        if not password.strip():
+            print_err("Error: password must not be empty.")
+            return None
+        return password
+    print_err(
+        "Error: password is required in non-interactive mode "
+        "(use --password or set LOGION_PASSWORD)."
+    )
+    return None
+
+
+def _field(obj: object, name: str) -> object:
+    """Read *name* from a dict or attribute-style response object."""
+    if isinstance(obj, dict):
+        return obj.get(name)
+    return getattr(obj, name, None)
+
+
+def _save_user_identity_from_result(result: object) -> None:
+    """Persist the created user's id/email; never fail the command."""
+    user = _field(result, "user")
+    if user is None:
+        return
+    user_id = _field(user, "id")
+    if user_id is None:
+        return
+    email = _field(user, "email")
+    try:
+        save_user_identity(
+            str(user_id),
+            email=str(email) if email is not None else None,
+        )
+    except OSError as exc:
+        print_err(f"Warning: could not save credentials: {exc}")
+
+
+def _resolve_user_id(cli_value: str | None) -> str | None:
+    """Return ``--user-id`` or the stored credential, ``None`` if neither."""
+    if cli_value is not None:
+        return cli_value
+    stored = stored_user_id()
+    if stored is not None:
+        return stored
+    print_err(
+        "Error: --user-id is required (no stored user found — run "
+        "`logion identity users-create` or pass --user-id)."
+    )
+    return None
+
+
+def handle_users_create(args: argparse.Namespace) -> int:
+    """Execute the identity users-create command."""
+    password = _resolve_password(args.password)
+    if password is None:
+        return 2
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.identity.create_user_with_agent(
+            email=args.email,
+            user_password=password,
+            agent_name=args.agent_name,
+            user_name=args.user_name,
+            agent_description=args.agent_description,
+        )
+        _save_user_identity_from_result(result)
+        print_err(API_KEY_WARNING)
+        emit(result, json_output=config.json_output)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_agents_add(args: argparse.Namespace) -> int:
+    """Execute the identity agents-add command."""
+    user_id = _resolve_user_id(args.user_id)
+    if user_id is None:
+        return 2
+    password = _resolve_password(args.password)
+    if password is None:
+        return 2
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.identity.add_agent_to_user(
+            user_id=user_id,
+            agent_name=args.agent_name,
+            user_password=password,
+            agent_description=args.agent_description,
+        )
+        print_err(API_KEY_WARNING)
+        emit(result, json_output=config.json_output)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_agents_rotate_key(args: argparse.Namespace) -> int:
+    """Execute the identity agents-rotate-key command."""
+    user_id = _resolve_user_id(args.user_id)
+    if user_id is None:
+        return 2
+    password = _resolve_password(args.password)
+    if password is None:
+        return 2
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.identity.rotate_api_key(
+            user_id=user_id,
+            agent_id=args.agent_id,
+            user_password=password,
+        )
+        print_err(API_KEY_WARNING)
+        emit(result, json_output=config.json_output)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()