movitera-cli 0.1.0__py3-none-any.whl

movitera_cli/__init__.py

@@ -0,0 +1,25 @@
+"""Movitera CLI for vault secrets, dotenv export, TOTP codes.
+
+Also exposes a small SDK surface for programmatic use:
+
+    from movitera_cli import VaultClient
+    from movitera_cli.token_store import load_token
+
+    client = VaultClient(api_url="https://api.movitera.com", token=load_token())
+    env = client.get_env(team_id="...", name="myapp-prod")  # raw dotenv text
+
+That's intentionally thin — the API itself is the SDK. We don't wrap it in
+domain objects because the surface evolves with the backend and the wire
+shape is small enough to consume directly.
+"""
+
+from movitera_cli.client import AccessTokenSummary, MoviteraError, VaultClient
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AccessTokenSummary",
+    "MoviteraError",
+    "VaultClient",
+    "__version__",
+]

movitera_cli/client.py

@@ -0,0 +1,131 @@
+"""HTTP client wrapping the Movitera vault API for the CLI.
+
+Thin wrapper around `httpx` that:
+- Adds the `Authorization: Bearer <pat>` header.
+- Surfaces server `errorCode` strings in raised exceptions so the CLI can
+  print actionable messages (e.g. CREDENTIAL_NAME_NOT_UNIQUE → "try --id").
+- Picks `text/plain` vs JSON correctly per endpoint.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+
+class MoviteraError(Exception):
+    """API call returned a non-2xx response we want to surface to the user."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        error_code: str | None = None,
+    ):
+        super().__init__(message)
+        self.status_code = status_code
+        self.error_code = error_code
+
+
+@dataclass(frozen=True)
+class AccessTokenSummary:
+    id: str
+    name: str
+    prefix: str
+    clientKind: str
+    createdAt: str
+    expiresAt: str | None
+    lastUsedAt: str | None
+
+
+class VaultClient:
+    def __init__(self, api_url: str, token: str, *, timeout: float = 30.0):
+        self._client = httpx.Client(
+            base_url=api_url,
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=timeout,
+        )
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> VaultClient:
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+    # ----- env bundle (CLI hot path) ------------------------------------
+
+    def get_env(self, team_id: str, name: str) -> str:
+        """Return raw dotenv text for the named ENV_BUNDLE credential."""
+        response = self._client.get(
+            f"/vault/credentials/by-name/{name}/env",
+            params={"teamId": team_id},
+        )
+        self._raise_for_status(response)
+        return response.text
+
+    # ----- TOTP ----------------------------------------------------------
+
+    def get_totp(self, credential_id: str) -> tuple[str, str]:
+        """Return (code, ISO-8601 expiresAt) from the server-side endpoint."""
+        response = self._client.get(f"/vault/credentials/{credential_id}/totp")
+        self._raise_for_status(response)
+        body = response.json()
+        return body["code"], body["expiresAt"]
+
+    # ----- access tokens (self-service) ---------------------------------
+
+    def list_access_tokens(self, team_id: str) -> list[AccessTokenSummary]:
+        response = self._client.get(
+            "/vault/access-tokens", params={"teamId": team_id}
+        )
+        self._raise_for_status(response)
+        return [
+            AccessTokenSummary(
+                id=item["id"],
+                name=item["name"],
+                prefix=item["prefix"],
+                clientKind=item["clientKind"],
+                createdAt=item["createdAt"],
+                expiresAt=item.get("expiresAt"),
+                lastUsedAt=item.get("lastUsedAt"),
+            )
+            for item in response.json()
+        ]
+
+    def revoke_access_token(self, token_id: str) -> None:
+        response = self._client.delete(f"/vault/access-tokens/{token_id}")
+        self._raise_for_status(response)
+
+    # ----- error handling -----------------------------------------------
+
+    @staticmethod
+    def _raise_for_status(response: httpx.Response) -> None:
+        if response.is_success:
+            return
+        error_code: str | None = None
+        message: str = response.text
+        try:
+            body = response.json()
+            detail = body.get("detail") if isinstance(body, dict) else None
+            if isinstance(detail, dict):
+                error_code = detail.get("errorCode")
+                messages = detail.get("errorMessages") or {}
+                # Prefer en-US; fall back to whatever's there.
+                message = (
+                    messages.get("en-US")
+                    or next(iter(messages.values()), None)
+                    or message
+                )
+        except ValueError:
+            pass
+        raise MoviteraError(
+            message,
+            status_code=response.status_code,
+            error_code=error_code,
+        )

movitera_cli/config.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+_DEFAULT_API_URL = "https://api.movitera.com"
+
+
+@dataclass(frozen=True)
+class Settings:
+    api_url: str
+    default_team_id: str | None
+    inline_token: str | None
+
+    @classmethod
+    def from_env(cls) -> Settings:
+        return cls(
+            api_url=os.environ.get("MOVITERA_API_URL", _DEFAULT_API_URL).rstrip("/"),
+            default_team_id=os.environ.get("MOVITERA_TEAM") or None,
+            # MOVITERA_TOKEN lets CI runners skip the keyring entirely.
+            inline_token=os.environ.get("MOVITERA_TOKEN") or None,
+        )

movitera_cli/main.py

@@ -0,0 +1,307 @@
+"""Movitera CLI entry point.
+
+Sub-commands:
+  login / logout      Manage the stored personal access token.
+  run                 Exec a child process with secrets injected as env vars.
+  secrets pull        Dump the secret bundle as dotenv on stdout.
+  totp                Print the current TOTP code for a credential.
+  tokens list/revoke  Self-service PAT management.
+"""
+
+from __future__ import annotations
+
+import os
+import shlex
+import sys
+from typing import NoReturn
+
+import click
+
+from movitera_cli.client import MoviteraError, VaultClient
+from movitera_cli.config import Settings
+from movitera_cli.token_store import clear_token, load_token, save_token
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _resolve_token(settings: Settings) -> str:
+    """Return the PAT or exit with a `movitera login` hint.
+
+    `MOVITERA_TOKEN` overrides the keyring so CI runners can inject the PAT
+    directly via environment variable without touching disk.
+    """
+    if settings.inline_token:
+        return settings.inline_token
+    token = load_token()
+    if not token:
+        click.echo(
+            "No vault access token found. Run `movitera login` to store one,"
+            " or set MOVITERA_TOKEN.",
+            err=True,
+        )
+        raise SystemExit(1)
+    return token
+
+
+def _resolve_team_id(settings: Settings, override: str | None) -> str:
+    team_id = override or settings.default_team_id
+    if not team_id:
+        click.echo(
+            "Missing team id. Pass --team or set MOVITERA_TEAM.", err=True
+        )
+        raise SystemExit(1)
+    return team_id
+
+
+def _vault_client(settings: Settings) -> VaultClient:
+    return VaultClient(api_url=settings.api_url, token=_resolve_token(settings))
+
+
+def _fail_with_movitera_error(exc: MoviteraError) -> NoReturn:
+    """Translate API errors into actionable CLI messages."""
+    hint = ""
+    if exc.error_code == "CREDENTIAL_NAME_NOT_UNIQUE":
+        hint = (
+            "\nMultiple credentials match that name. Disambiguate by id or"
+            " rename one of them in the web app."
+        )
+    elif exc.error_code == "CREDENTIAL_KIND_MISMATCH":
+        hint = (
+            "\nThe credential exists but isn't an ENV_BUNDLE. Use a different"
+            " credential, or change its kind in the web app."
+        )
+    elif exc.error_code == "CREDENTIAL_TOTP_NOT_CONFIGURED":
+        hint = (
+            "\nThis credential has no OTPAUTH_URI field. Add one in the web"
+            " app to enable TOTP."
+        )
+    elif exc.error_code == "VAULT_ACCESS_TOKEN_INVALID":
+        hint = "\nYour PAT is revoked or expired. Run `movitera login` again."
+    click.echo(f"Error: {exc}{hint}", err=True)
+    raise SystemExit(2)
+
+
+# ---------------------------------------------------------------------------
+# Click app
+# ---------------------------------------------------------------------------
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.version_option(package_name="movitera-cli", prog_name="movitera")
+def cli() -> None:
+    """Movitera vault CLI."""
+
+
+@cli.command()
+@click.option(
+    "--stdin",
+    "from_stdin",
+    is_flag=True,
+    help="Read the PAT from stdin instead of prompting.",
+)
+def login(from_stdin: bool) -> None:
+    """Store a Movitera vault access token in the OS keyring."""
+    if from_stdin:
+        token = sys.stdin.read().strip()
+    else:
+        token = click.prompt(
+            "Paste your Movitera vault PAT (input hidden)",
+            hide_input=True,
+        ).strip()
+    if not token:
+        click.echo("Empty token; nothing saved.", err=True)
+        raise SystemExit(1)
+    if not token.startswith("mvt_pat_"):
+        click.echo(
+            "Token doesn't look like a vault PAT (missing `mvt_pat_` prefix).",
+            err=True,
+        )
+        raise SystemExit(1)
+    backend = save_token(token)
+    click.echo(f"Token saved to {backend}.")
+
+
+@cli.command()
+def logout() -> None:
+    """Remove the stored Movitera vault access token."""
+    clear_token()
+    click.echo("Stored token removed.")
+
+
+@cli.command(
+    name="run",
+    context_settings={
+        # Pass everything after `--` straight to the child process.
+        "ignore_unknown_options": True,
+        "allow_extra_args": True,
+    },
+)
+@click.option("--team", "team_id", default=None)
+@click.option(
+    "--credential",
+    "credential_name",
+    required=True,
+    help="Name of the ENV_BUNDLE credential to load.",
+)
+@click.argument("argv", nargs=-1, type=click.UNPROCESSED)
+def run_cmd(
+    team_id: str | None, credential_name: str, argv: tuple[str, ...]
+) -> None:
+    """Exec a command with vault secrets injected as env vars."""
+    if not argv:
+        click.echo(
+            "Provide a command to exec: `movitera run --credential X -- cmd`.",
+            err=True,
+        )
+        raise SystemExit(1)
+
+    settings = Settings.from_env()
+    team_id = _resolve_team_id(settings, team_id)
+
+    try:
+        with _vault_client(settings) as client:
+            dotenv_body = client.get_env(team_id=team_id, name=credential_name)
+    except MoviteraError as exc:
+        _fail_with_movitera_error(exc)
+
+    env = os.environ.copy()
+    env.update(_parse_dotenv(dotenv_body))
+
+    # `execvpe` replaces this process so signal handling stays clean (no
+    # Python supervisor in the middle). On Windows there's no `execvp` that
+    # respects PATH; we fall back to a subprocess.
+    cmd, *args = argv
+    if os.name == "nt":  # pragma: no cover - posix-only CI
+        import subprocess
+
+        result = subprocess.run([cmd, *args], env=env)
+        raise SystemExit(result.returncode)
+    os.execvpe(cmd, [cmd, *args], env)
+
+
+@cli.group(name="secrets")
+def secrets_group() -> None:
+    """Fetch and export vault secrets."""
+
+
+@secrets_group.command(name="pull")
+@click.option("--team", "team_id", default=None)
+@click.option(
+    "--credential",
+    "credential_name",
+    required=True,
+    help="Name of the ENV_BUNDLE credential.",
+)
+def secrets_pull(team_id: str | None, credential_name: str) -> None:
+    """Print the dotenv body to stdout (suitable for redirection)."""
+    settings = Settings.from_env()
+    team_id = _resolve_team_id(settings, team_id)
+    try:
+        with _vault_client(settings) as client:
+            body = client.get_env(team_id=team_id, name=credential_name)
+    except MoviteraError as exc:
+        _fail_with_movitera_error(exc)
+    # `body` already ends with a newline; preserve it as-is so the consumer
+    # gets a fully-formed dotenv file even when piped.
+    sys.stdout.write(body)
+
+
+@cli.command(name="totp")
+@click.argument("credential_id")
+def totp_cmd(credential_id: str) -> None:
+    """Print the current TOTP code for a credential."""
+    settings = Settings.from_env()
+    try:
+        with _vault_client(settings) as client:
+            code, expires_at = client.get_totp(credential_id=credential_id)
+    except MoviteraError as exc:
+        _fail_with_movitera_error(exc)
+    click.echo(code)
+    click.echo(f"(valid until {expires_at})", err=True)
+
+
+@cli.group(name="tokens")
+def tokens_group() -> None:
+    """Manage your own Movitera vault access tokens."""
+
+
+@tokens_group.command(name="list")
+@click.option("--team", "team_id", default=None)
+def tokens_list(team_id: str | None) -> None:
+    """List your active PATs in the team."""
+    settings = Settings.from_env()
+    team_id = _resolve_team_id(settings, team_id)
+    try:
+        with _vault_client(settings) as client:
+            tokens = client.list_access_tokens(team_id=team_id)
+    except MoviteraError as exc:
+        _fail_with_movitera_error(exc)
+    if not tokens:
+        click.echo("No active tokens.")
+        return
+    click.echo(
+        f"{'PREFIX':18}  {'NAME':30}  {'KIND':10}  {'EXPIRES':25}  ID"
+    )
+    for token in tokens:
+        click.echo(
+            f"{token.prefix:18}  {token.name[:30]:30}  "
+            f"{token.clientKind:10}  {str(token.expiresAt or 'never')[:25]:25}  "
+            f"{token.id}"
+        )
+
+
+@tokens_group.command(name="revoke")
+@click.argument("token_id")
+def tokens_revoke(token_id: str) -> None:
+    """Revoke a PAT by id."""
+    settings = Settings.from_env()
+    try:
+        with _vault_client(settings) as client:
+            client.revoke_access_token(token_id=token_id)
+    except MoviteraError as exc:
+        _fail_with_movitera_error(exc)
+    click.echo(f"Revoked {token_id}.")
+
+
+# ---------------------------------------------------------------------------
+# dotenv parsing (matches the server's quoting rules)
+# ---------------------------------------------------------------------------
+
+
+def _parse_dotenv(body: str) -> dict[str, str]:
+    """Parse the server's dotenv format back into a dict.
+
+    The server quotes values containing whitespace, `#`, quotes, or
+    backslashes (see `GetCredentialEnvService._render_dotenv`). We mirror
+    that here so quoting round-trips correctly.
+    """
+    out: dict[str, str] = {}
+    for line in body.splitlines():
+        line = line.rstrip("\r")
+        if not line or line.startswith("#"):
+            continue
+        if "=" not in line:
+            continue
+        key, _, raw_value = line.partition("=")
+        key = key.strip()
+        if not key:
+            continue
+        out[key] = _unquote_value(raw_value)
+    return out
+
+
+def _unquote_value(value: str) -> str:
+    value = value.strip()
+    if not value:
+        return ""
+    if value[0] == '"' and value[-1] == '"' and len(value) >= 2:
+        # Use shlex to handle backslash escapes consistently with most
+        # dotenv libraries; it understands `\"` and `\\` inside quotes.
+        try:
+            return next(iter(shlex.split(value)))
+        except ValueError:
+            return value
+    return value

movitera_cli/token_store.py

@@ -0,0 +1,94 @@
+"""Persistent PAT storage with keyring-first / file-fallback strategy.
+
+Keyring is preferred (OS-managed, encrypted at rest on most platforms).
+When no backend is available (headless Linux without libsecret, some CI
+runners), we fall back to a `0o600` file under `~/.config/movitera/token`.
+The keyring service name is fixed so multiple installs share storage.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+from pathlib import Path
+
+import keyring
+import keyring.errors
+
+_SERVICE = "movitera-cli"
+_USERNAME = "default"
+
+
+def _fallback_path() -> Path:
+    base = Path(
+        os.environ.get("MOVITERA_CONFIG_DIR")
+        or os.environ.get("XDG_CONFIG_HOME")
+        or (Path.home() / ".config")
+    )
+    return base / "movitera" / "token"
+
+
+def _try_keyring_get() -> str | None:
+    try:
+        return keyring.get_password(_SERVICE, _USERNAME)
+    except keyring.errors.KeyringError:
+        return None
+    except Exception:
+        # Some keyring backends raise platform-specific exceptions on init
+        # (e.g. macOS sandbox issues). Treat any failure as "not available".
+        return None
+
+
+def _try_keyring_set(token: str) -> bool:
+    try:
+        keyring.set_password(_SERVICE, _USERNAME, token)
+        return True
+    except Exception:
+        return False
+
+
+def _try_keyring_delete() -> bool:
+    try:
+        keyring.delete_password(_SERVICE, _USERNAME)
+        return True
+    except keyring.errors.PasswordDeleteError:
+        # Already gone — caller treats this as success.
+        return True
+    except Exception:
+        return False
+
+
+def load_token() -> str | None:
+    """Return the stored token, or None if none is stored."""
+    via_keyring = _try_keyring_get()
+    if via_keyring:
+        return via_keyring
+    path = _fallback_path()
+    if not path.exists():
+        return None
+    return path.read_text(encoding="utf-8").strip() or None
+
+
+def save_token(token: str) -> str:
+    """Persist `token` and return a human-readable backend label.
+
+    Tries the OS keyring first; falls back to a `0o600` file. The label is
+    surfaced in `movitera login` output so the user knows where the secret
+    actually landed.
+    """
+    if _try_keyring_set(token):
+        return "OS keyring"
+    path = _fallback_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(token, encoding="utf-8")
+    # Best-effort on Windows where chmod is largely a no-op; the file path
+    # itself is under the user's profile which already has restricted ACLs.
+    os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
+    return str(path)
+
+
+def clear_token() -> None:
+    _try_keyring_delete()
+    path = _fallback_path()
+    if path.exists():
+        path.unlink()

movitera_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: movitera-cli
+Version: 0.1.0
+Summary: Movitera CLI: inject vault secrets as environment variables, generate TOTP codes
+Project-URL: Homepage, https://github.com/joaoheusi/movitera-cli
+Project-URL: Repository, https://github.com/joaoheusi/movitera-cli
+Project-URL: Issues, https://github.com/joaoheusi/movitera-cli/issues
+Author: Movitera
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,dotenv,movitera,password-manager,secrets,totp,vault
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: <4,>=3.11
+Requires-Dist: click<9,>=8.1
+Requires-Dist: httpx<1,>=0.28.1
+Requires-Dist: keyring<26,>=25
+Requires-Dist: pyotp<3,>=2.9
+Description-Content-Type: text/markdown
+
+# movitera CLI
+
+Inject Movitera vault secrets as environment variables, render dotenv files, and generate TOTP codes from the terminal. Authenticates with a Movitera vault personal access token (PAT).
+
+## Install
+
+```bash
+pip install movitera-cli
+# or install as an isolated CLI tool (recommended):
+pipx install movitera-cli
+# or with uv:
+uv tool install movitera-cli
+# or run without installing:
+uvx --from movitera-cli movitera --help
+```
+
+## Quick start
+
+```bash
+# 1. Mint a PAT in the web app (Settings → Vault → Access Tokens),
+#    then paste it once:
+movitera login
+
+# 2. Run any command with secrets injected as env vars:
+movitera run --team <teamId> --credential myapp-prod -- npm start
+
+# 3. Or dump as dotenv:
+movitera secrets pull --team <teamId> --credential myapp-prod > .env
+
+# 4. Or generate a TOTP code for a credential:
+movitera totp --team <teamId> <credential-id>
+```
+
+## How it works
+
+`movitera run -- cmd` fetches the dotenv body from
+`GET /vault/credentials/by-name/{name}/env`, then `exec`s the child process
+with those vars merged into its environment. The CLI never writes secrets
+to disk — they exist only in the child process's `environ`.
+
+Tokens are stored in the OS keyring (Keychain on macOS, libsecret on Linux,
+Credential Manager on Windows) with a file fallback under
+`~/.config/movitera/token` (mode `0o600`) if no keyring backend is
+available.
+
+## Config
+
+| Env var | Purpose | Default |
+|---|---|---|
+| `MOVITERA_API_URL` | API base URL | `https://api.movitera.com` |
+| `MOVITERA_TOKEN` | PAT override (skips keyring lookup) | — |
+| `MOVITERA_TEAM` | Default team id (you can omit `--team`) | — |
+
+## Commands
+
+### `movitera login`
+Prompts for a PAT (or reads it from stdin via `--stdin`) and stores it.
+
+### `movitera logout`
+Removes the stored PAT.
+
+### `movitera run --team T --credential N -- <cmd> [args...]`
+Fetches the `ENV_BUNDLE` credential named `N` and execs `<cmd>` with those
+vars in the environment.
+
+### `movitera secrets pull --team T --credential N`
+Writes the dotenv body to stdout. Exits non-zero on resolution failures so
+you can chain `movitera secrets pull ... > .env`.
+
+### `movitera totp --team T <credential-id>`
+Prints the current TOTP code for the credential's `OTPAUTH_URI` field.
+
+### `movitera tokens list --team T` / `movitera tokens revoke <id>`
+Manage your own PATs from the CLI.
+
+## Security model
+
+- PATs have full 256-bit entropy and are stored as SHA-256 on the server,
+  so a server compromise cannot recover the plaintext.
+- Every `movitera run` invocation is audited server-side, but PAT reads
+  are **coalesced per hour per token** (see the backend's
+  `FETCHED_VIA_TOKEN` aggregation) so a hot dev loop doesn't drown the log.
+- Group/team access is re-checked on every request: if your vault scope is
+  revoked, your PAT immediately loses access — no token-cache divergence.

movitera_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+movitera_cli/__init__.py,sha256=txXIGmjoER6_uoF31Ov8NSd3mHGBpQ6a6zHcu1Z_q3I,773
+movitera_cli/client.py,sha256=6GT6gjrxZYUyh94dioffMTk9der3wzqHKwHrQb5B3lg,4178
+movitera_cli/config.py,sha256=eHIlv8xwhVY0D28F4FrWCTXHcZqUNidGVyGpyOF2aEs,624
+movitera_cli/main.py,sha256=zIu8xTeMATWBgSY-SJjjJA8i8ibPkK8pk-u6Upenikg,9850
+movitera_cli/token_store.py,sha256=GCfATXx069r3bqWNi1SiUR0qtmVd5g-A00Yj3C-ehrM,2706
+movitera_cli-0.1.0.dist-info/METADATA,sha256=mkOzvz_ks89nemyC3S2w47tbyj8WUVDgvnjBq3gv0kQ,4054
+movitera_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+movitera_cli-0.1.0.dist-info/entry_points.txt,sha256=6sWijoQPmre_WeO7YAuyMXrAE_WpiPLxkOBsQJbRPIo,51
+movitera_cli-0.1.0.dist-info/licenses/LICENSE,sha256=xNq9eLDnrXYIKD_6XLk0PovSlTCl8Fpk49E8aMnGLFk,1065
+movitera_cli-0.1.0.dist-info/RECORD,,

movitera_cli-0.1.0.dist-info/WHEEL

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

movitera_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+movitera = movitera_cli.main:cli

movitera_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Movitera
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.