granny-devops 0.4.0__py3-none-any.whl

granny/cli/edge.py

@@ -0,0 +1,106 @@
+"""``granny edge`` — Bunny Edge Scripting management."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+
+def _client(customer: str | None = None):
+    from granny.edge.bunny import BunnyEdgeScriptClient
+
+    return BunnyEdgeScriptClient(customer=customer)
+
+
+customer_option = click.option("--customer", "-c", default=None)
+
+
+@click.group()
+def edge() -> None:
+    """Bunny Edge Scripting management."""
+
+
+@edge.command("list")
+@customer_option
+def list_cmd(customer: str | None) -> None:
+    """List all edge scripts."""
+    c = _client(customer)
+    scripts = c.list_scripts()
+    if not scripts:
+        click.echo("No edge scripts found.")
+        return
+    for s in scripts:
+        click.echo(f"  {s.get('Id', '?'):<10} {s.get('Name', '?'):<30} Type={s.get('ScriptType', '?')}")
+
+
+@edge.command("create")
+@click.argument("name")
+@click.option("--code", "code_path", type=click.Path(exists=True), default=None)
+@click.option(
+    "--type",
+    "script_type",
+    type=click.Choice(["standalone", "middleware"]),
+    default="standalone",
+    show_default=True,
+)
+@customer_option
+def create_cmd(
+    name: str, code_path: str | None, script_type: str, customer: str | None
+) -> None:
+    """Create an edge script."""
+    c = _client(customer)
+    code = Path(code_path).read_text(encoding="utf-8") if code_path else ""
+    result = c.create_script(name, code=code, script_type=script_type)
+    click.echo(f"Script created: ID={result.get('Id')} Name={result.get('Name')}")
+    if result.get("LinkedPullZones"):
+        pz = result["LinkedPullZones"][0]
+        click.echo(f"Linked pull zone: ID={pz.get('Id')} Name={pz.get('Name')}")
+
+
+@edge.command("deploy")
+@click.argument("script_id", type=int)
+@click.argument("code_path", type=click.Path(exists=True))
+@customer_option
+def deploy_cmd(script_id: int, code_path: str, customer: str | None) -> None:
+    """Deploy code to an edge script."""
+    c = _client(customer)
+    code = Path(code_path).read_text(encoding="utf-8")
+    c.deploy_code(script_id, code)
+    click.echo(f"Code deployed to script {script_id} ({len(code)} bytes).")
+
+
+@edge.command("publish")
+@click.argument("script_id", type=int)
+@customer_option
+def publish_cmd(script_id: int, customer: str | None) -> None:
+    """Publish the current code as a live release."""
+    c = _client(customer)
+    c.publish(script_id)
+    click.echo(f"Script {script_id} published.")
+
+
+@edge.command("env")
+@click.argument("script_id", type=int)
+@click.argument("pairs", nargs=-1)
+@customer_option
+def env_cmd(script_id: int, pairs: tuple[str, ...], customer: str | None) -> None:
+    """Set environment variables (KEY=VALUE pairs).
+
+    If no pairs given, lists current variables.
+    """
+    c = _client(customer)
+    if not pairs:
+        variables = c.list_variables(script_id)
+        if not variables:
+            click.echo("No variables set.")
+            return
+        for v in variables:
+            click.echo(f"  {v.get('Name', '?')}={v.get('DefaultValue', '')}")
+        return
+    for pair in pairs:
+        if "=" not in pair:
+            raise click.UsageError(f"Invalid format: {pair!r}. Use KEY=VALUE.")
+        key, _, value = pair.partition("=")
+        c.upsert_variable(script_id, key, value)
+        click.echo(f"  Set {key}")

granny/cli/email.py

@@ -0,0 +1,224 @@
+"""``granny email`` — Mailjet + AWS WorkMail management."""
+
+from __future__ import annotations
+
+import getpass
+
+import click
+
+
+@click.group()
+def email() -> None:
+    """Email management (Mailjet, WorkMail)."""
+
+
+# -- Mailjet subgroup ---------------------------------------------------------
+
+
+@email.group("mailjet")
+def mailjet() -> None:
+    """Mailjet sender/DNS and contact management."""
+
+
+@mailjet.command("setup-dns")
+@click.argument("domain")
+@click.option("--check", "check_only", is_flag=True, help="Read-only DNS status check.")
+@click.option("--dry-run", is_flag=True)
+def mailjet_setup_dns(domain: str, check_only: bool, dry_run: bool) -> None:
+    """Register domain sender and retrieve DNS auth settings.
+
+    Prints the DKIM, SPF, and ownership values you need to create as TXT
+    records. Use ``granny dns`` to create them.
+    """
+    from granny.email.mailjet import MailjetClient
+
+    c = MailjetClient()
+
+    if check_only:
+        sender = c.find_sender(domain)
+        if not sender:
+            click.echo(f"No sender registered for *@{domain}")
+            raise SystemExit(1)
+        dns = c.get_dns_settings(domain)
+        click.echo(f"DKIM status: {dns.get('DKIMStatus')}")
+        click.echo(f"SPF status:  {dns.get('SPFStatus')}")
+        return
+
+    sender = c.get_or_create_sender(domain)
+    click.echo(f"Sender: *@{domain} (ID={sender.get('ID')}, Status={sender.get('Status')})")
+
+    dns = c.get_dns_settings(domain)
+    click.echo("")
+    click.echo("DNS records to create:")
+    click.echo(f"  DKIM:  TXT  {dns.get('DKIMRecordName', 'mailjet._domainkey.' + domain)}")
+    click.echo(f"         {dns.get('DKIMRecordValue', '(not available)')}")
+    click.echo(f"  SPF:   TXT  {domain}")
+    click.echo(f"         {dns.get('SPFRecordValue', 'v=spf1 include:spf.mailjet.com ~all')}")
+    if dns.get("OwnerShipToken"):
+        click.echo(f"  Owner: TXT  {dns.get('OwnerShipTokenRecordName', domain)}")
+        click.echo(f"         {dns.get('OwnerShipToken')}")
+
+
+@mailjet.command("check-contact")
+@click.argument("email_address")
+def mailjet_check_contact(email_address: str) -> None:
+    """Check a contact's status (blocked, active, bounce history)."""
+    from granny.email.mailjet_contacts import MailjetContactClient
+
+    c = MailjetContactClient()
+    contact = c.get_contact(email_address)
+    if not contact:
+        click.echo(f"Contact not found: {email_address}")
+        raise SystemExit(1)
+
+    excluded = contact.get("IsExcludedFromCampaigns", False)
+    status = "BLOCKED" if excluded else "ACTIVE"
+    click.echo(f"Email:    {contact.get('Email')}")
+    click.echo(f"Status:   {status}")
+    click.echo(f"ID:       {contact.get('ID')}")
+    click.echo(f"Created:  {contact.get('CreatedAt', 'N/A')}")
+    click.echo(f"Activity: {contact.get('LastActivityAt', 'N/A')}")
+
+
+@mailjet.command("unblock")
+@click.argument("email_address")
+@click.option("--yes", is_flag=True, help="Skip confirmation.")
+def mailjet_unblock(email_address: str, yes: bool) -> None:
+    """Unblock a contact excluded from campaigns."""
+    from granny.email.mailjet_contacts import MailjetContactClient
+
+    c = MailjetContactClient()
+    contact = c.get_contact(email_address)
+    if not contact:
+        click.echo(f"Contact not found: {email_address}")
+        raise SystemExit(1)
+    if not contact.get("IsExcludedFromCampaigns"):
+        click.echo(f"{email_address} is already active.")
+        return
+    if not yes:
+        click.confirm(f"Unblock {email_address}?", abort=True)
+    c.unblock_contact(email_address)
+    click.echo(f"Unblocked: {email_address}")
+
+
+@mailjet.command("list-blocked")
+@click.option("--domain", default=None, help="Filter by domain.")
+def mailjet_list_blocked(domain: str | None) -> None:
+    """List contacts excluded from campaigns."""
+    from granny.email.mailjet_contacts import MailjetContactClient
+
+    c = MailjetContactClient()
+    contacts = c.list_all_excluded(domain=domain)
+    if not contacts:
+        click.echo("No blocked contacts found.")
+        return
+    click.echo(f"Blocked contacts ({len(contacts)}):")
+    for ct in contacts:
+        click.echo(f"  {ct.get('Email', '?'):<40} ID={ct.get('ID')}")
+
+
+# -- WorkMail subgroup --------------------------------------------------------
+
+
+@email.group("workmail")
+def workmail() -> None:
+    """AWS WorkMail user management."""
+
+
+@workmail.command("list-orgs")
+@click.option("--region", default=None, help="AWS region (default: us-east-1).")
+def workmail_list_orgs(region: str | None) -> None:
+    """List WorkMail organizations."""
+    from granny.email.workmail import WorkMailManager
+
+    wm = WorkMailManager(region=region)
+    orgs = wm.list_organizations()
+    if not orgs:
+        click.echo("No organizations found.")
+        return
+    for org in orgs:
+        click.echo(
+            f"  {org.get('OrganizationId', '?'):<40} "
+            f"{org.get('DefaultMailDomain', org.get('Alias', '?')):<30} "
+            f"{org.get('State', '?')}"
+        )
+
+
+@workmail.command("list-users")
+@click.argument("domain")
+@click.option("--region", default=None)
+def workmail_list_users(domain: str, region: str | None) -> None:
+    """List users in a WorkMail organization."""
+    from granny.email.workmail import WorkMailManager
+
+    wm = WorkMailManager(region=region)
+    org_id = wm.get_org_id(domain)
+    users = wm.list_users(org_id)
+    for u in users:
+        if u.get("UserRole") == "SYSTEM_USER":
+            continue
+        click.echo(
+            f"  {u.get('Email', '?'):<40} "
+            f"{u.get('DisplayName', ''):<20} "
+            f"{u.get('State', '?')}"
+        )
+
+
+@workmail.command("create-user")
+@click.argument("domain")
+@click.option("--email", "user_email", required=True)
+@click.option("--display-name", required=True)
+@click.option("--first-name", default=None)
+@click.option("--last-name", default=None)
+@click.option("--region", default=None)
+def workmail_create_user(
+    domain: str,
+    user_email: str,
+    display_name: str,
+    first_name: str | None,
+    last_name: str | None,
+    region: str | None,
+) -> None:
+    """Create a WorkMail user (password prompted interactively)."""
+    from granny.email.workmail import WorkMailManager
+
+    password = getpass.getpass("Password: ")
+    password2 = getpass.getpass("Confirm:  ")
+    if password != password2:
+        raise click.ClickException("Passwords do not match.")
+
+    wm = WorkMailManager(region=region)
+    org_id = wm.get_org_id(domain)
+    user_id = wm.create_and_register_user(
+        org_id,
+        user_email,
+        display_name,
+        password,
+        first_name=first_name,
+        last_name=last_name,
+    )
+    click.echo(f"User created: {user_email} (ID={user_id})")
+
+
+@workmail.command("reset-password")
+@click.argument("domain")
+@click.option("--email", "user_email", required=True)
+@click.option("--region", default=None)
+def workmail_reset_password(
+    domain: str, user_email: str, region: str | None
+) -> None:
+    """Reset a WorkMail user's password."""
+    from granny.email.workmail import WorkMailManager
+
+    password = getpass.getpass("New password: ")
+    password2 = getpass.getpass("Confirm:      ")
+    if password != password2:
+        raise click.ClickException("Passwords do not match.")
+
+    wm = WorkMailManager(region=region)
+    org_id = wm.get_org_id(domain)
+    user = wm.find_user_by_email(org_id, user_email)
+    if not user:
+        raise click.ClickException(f"User not found: {user_email}")
+    wm.reset_password(org_id, user["Id"], password)
+    click.echo(f"Password reset for {user_email}.")

granny/cli/main.py

@@ -0,0 +1,98 @@
+"""Granny CLI entrypoint.
+
+Thin wrapper around library functions -- no business logic here.
+"""
+
+from pathlib import Path
+
+import click
+from dotenv import load_dotenv
+
+from granny import __version__
+
+# Auto-load a project-local dotenv from CWD so explicit values override the
+# vault. `.deploy.env` is preferred (matches scripts/deploy.sh), `.env` is a
+# fallback. override=True means these entries beat anything already exported.
+for _candidate in (".deploy.env", ".env"):
+    _path = Path.cwd() / _candidate
+    if _path.is_file():
+        load_dotenv(_path, override=True)
+        break
+
+
+@click.group()
+@click.version_option(__version__, prog_name="granny")
+@click.option("--verbose", is_flag=True, help="Show debug output")
+@click.option("--quiet", is_flag=True, help="Suppress warnings")
+def cli(verbose: bool, quiet: bool) -> None:
+    """Granny -- Cloud tools collection."""
+    import logging
+
+    if verbose:
+        logging.basicConfig(level=logging.DEBUG, format="%(name)s: %(message)s")
+    elif quiet:
+        logging.basicConfig(level=logging.ERROR)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+
+# Register command groups -------------------------------------------------
+
+def _register_commands() -> None:
+    """Register available command groups."""
+    try:
+        from granny.cli.credentials import credentials
+        cli.add_command(credentials)
+    except ImportError:
+        pass
+    try:
+        from granny.cli.analyze import analyze
+        cli.add_command(analyze)
+    except ImportError:
+        pass
+    try:
+        from granny.cli.cdn import cdn
+        cli.add_command(cdn)
+    except ImportError:
+        pass
+    try:
+        from granny.cli.create import create
+        cli.add_command(create)
+    except ImportError:
+        pass
+    try:
+        from granny.cli.docker import docker
+        cli.add_command(docker)
+    except ImportError:
+        pass
+    try:
+        from granny.cli.dns import dns
+        cli.add_command(dns)
+    except ImportError:
+        pass
+    try:
+        from granny.cli.storage import storage
+        cli.add_command(storage)
+    except ImportError:
+        pass
+    try:
+        from granny.cli.edge import edge
+        cli.add_command(edge)
+    except ImportError:
+        pass
+    try:
+        from granny.cli.serverless import serverless
+        cli.add_command(serverless)
+    except ImportError:
+        pass
+    try:
+        from granny.cli.email import email
+        cli.add_command(email)
+    except ImportError:
+        pass
+
+
+_register_commands()
+
+if __name__ == "__main__":
+    cli()

granny/cli/serverless.py

@@ -0,0 +1,278 @@
+"""``granny serverless`` — Scaleway Functions (FaaS) management."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+import click
+
+
+def _client(region: str):
+    from granny.serverless.scaleway import ScalewayFunctionsClient
+
+    return ScalewayFunctionsClient(region=region)
+
+
+region_option = click.option(
+    "--region",
+    default="fr-par",
+    show_default=True,
+    type=click.Choice(["fr-par", "nl-ams", "pl-waw"]),
+)
+
+
+@click.group()
+def serverless() -> None:
+    """Scaleway Functions (FaaS) management."""
+
+
+@serverless.command("list-namespaces")
+@region_option
+def list_namespaces(region: str) -> None:
+    """List all function namespaces."""
+    c = _client(region)
+    for ns in c.list_namespaces():
+        click.echo(f"  {ns.get('id', '?')[:12]}  {ns.get('name', '?'):<30} {ns.get('status', '?')}")
+
+
+@serverless.command("create-namespace")
+@click.argument("name")
+@click.option("--description", default="")
+@region_option
+def create_namespace(name: str, description: str, region: str) -> None:
+    """Create a function namespace."""
+    c = _client(region)
+    result = c.create_namespace(name, description=description)
+    click.echo(f"Namespace created: {result.get('id')} ({result.get('name')})")
+
+
+@serverless.command("list-functions")
+@click.argument("namespace_id")
+@region_option
+def list_functions(namespace_id: str, region: str) -> None:
+    """List functions in a namespace."""
+    c = _client(region)
+    for fn in c.list_functions(namespace_id):
+        click.echo(
+            f"  {fn.get('id', '?')[:12]}  {fn.get('name', '?'):<20} "
+            f"runtime={fn.get('runtime', '?')} status={fn.get('status', '?')}"
+        )
+
+
+@serverless.command("create-function")
+@click.argument("namespace_id")
+@click.argument("name")
+@click.option(
+    "--runtime",
+    default="node20",
+    show_default=True,
+    type=click.Choice(
+        ["node20", "node22", "python311", "python312", "go121", "rust165"]
+    ),
+)
+@click.option("--handler", default="handler.handler", show_default=True)
+@click.option("--memory", default=256, show_default=True, type=int)
+@click.option("--timeout", default="30s", show_default=True)
+@click.option("--min-scale", default=0, show_default=True, type=int)
+@click.option("--max-scale", default=5, show_default=True, type=int)
+@region_option
+def create_function(
+    namespace_id: str,
+    name: str,
+    runtime: str,
+    handler: str,
+    memory: int,
+    timeout: str,
+    min_scale: int,
+    max_scale: int,
+    region: str,
+) -> None:
+    """Create a function in a namespace."""
+    c = _client(region)
+    result = c.create_function(
+        namespace_id,
+        name,
+        runtime=runtime,
+        handler=handler,
+        memory_limit=memory,
+        timeout=timeout,
+        min_scale=min_scale,
+        max_scale=max_scale,
+    )
+    click.echo(f"Function created: {result.get('id')} ({result.get('name')})")
+    if result.get("domain_name"):
+        click.echo(f"Endpoint: https://{result['domain_name']}")
+
+
+# Patterns that bloat a function package without contributing to runtime.
+# Matches both whole path segments and trailing-name globs.
+_DEFAULT_EXCLUDES = (
+    "*.map", "*.d.ts", "*.d.ts.map",
+    "node_modules/.cache/*",
+    "node_modules/@types/*",
+    "node_modules/typescript/*",
+    "node_modules/jest*/*",
+    "node_modules/ts-jest/*",
+    "node_modules/eslint*/*",
+    "node_modules/prettier/*",
+    "node_modules/@typescript-eslint/*",
+    "node_modules/supertest/*",
+    "node_modules/jest-junit/*",
+    "node_modules/tsx/*",
+    "node_modules/.yarn-state.yml",
+    "node_modules/*/README.md",
+    "node_modules/*/CHANGELOG.md",
+    "node_modules/*/LICENSE*",
+    "node_modules/*/.github/*",
+    "node_modules/*/test/*",
+    "node_modules/*/tests/*",
+    "node_modules/*/__tests__/*",
+)
+
+
+def _zip_package(source_dir: Path, out_path: Path) -> None:
+    """Zip the contents of source_dir, applying default excludes.
+
+    Prefers the `zip` CLI if available (preserves symlinks / perms correctly
+    on Linux CI); falls back to zipfile.
+    """
+    if shutil.which("zip"):
+        cmd = ["zip", "-qr", str(out_path), "."]
+        for pat in _DEFAULT_EXCLUDES:
+            cmd += ["-x", pat]
+        subprocess.run(cmd, cwd=source_dir, check=True)
+        return
+
+    # Python fallback — doesn't apply excludes (best-effort), just zips everything
+    with zipfile.ZipFile(out_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for path in source_dir.rglob("*"):
+            if path.is_file():
+                zf.write(path, path.relative_to(source_dir))
+
+
+def _parse_env_pairs(pairs: tuple[str, ...]) -> dict[str, str]:
+    env = {}
+    for p in pairs:
+        if "=" not in p:
+            raise click.BadParameter(f"Expected KEY=VALUE, got: {p}")
+        k, v = p.split("=", 1)
+        env[k.strip()] = v
+    return env
+
+
+def _parse_secret_pairs(pairs: tuple[str, ...]) -> list[dict]:
+    secrets = []
+    for p in pairs:
+        if "=" not in p:
+            raise click.BadParameter(f"Expected KEY=VALUE, got: {p}")
+        k, v = p.split("=", 1)
+        secrets.append({"key": k.strip(), "value": v})
+    return secrets
+
+
+@serverless.command("deploy")
+@click.argument("function_name")
+@click.option(
+    "--source-dir", "source_dir",
+    type=click.Path(exists=True, file_okay=False, path_type=Path),
+    required=True,
+    help="Directory to package (zipped and uploaded verbatim).",
+)
+@click.option(
+    "--namespace", "namespace_name",
+    help="Namespace name. If omitted, the function must be uniquely named across all namespaces.",
+)
+@click.option(
+    "--env", "env_pairs", multiple=True, metavar="KEY=VALUE",
+    help="Non-secret environment variable (repeatable).",
+)
+@click.option(
+    "--secret", "secret_pairs", multiple=True, metavar="KEY=VALUE",
+    help="Secret environment variable (repeatable).",
+)
+@click.option(
+    "--env-json",
+    help="Path to JSON file containing {env: {...}, secrets: [{key,value}]}.",
+)
+@region_option
+def deploy(
+    function_name: str,
+    source_dir: Path,
+    namespace_name: str | None,
+    env_pairs: tuple[str, ...],
+    secret_pairs: tuple[str, ...],
+    env_json: str | None,
+    region: str,
+) -> None:
+    """Zip ``--source-dir``, upload, sync env vars, and deploy.
+
+    Example:
+        granny serverless deploy bessa-wissa-api \\
+            --source-dir backend/dist-bundle \\
+            --namespace bessa-wissa \\
+            --env NODE_ENV=production \\
+            --secret STOZ3N_API_TOKEN=$STOZ3N_API_TOKEN
+    """
+    c = _client(region)
+
+    # Resolve function id
+    function = None
+    if namespace_name:
+        ns = c.find_namespace(namespace_name)
+        if not ns:
+            raise click.ClickException(f"Namespace '{namespace_name}' not found")
+        function = c.find_function(ns["id"], function_name)
+    else:
+        for ns in c.list_namespaces():
+            fn = c.find_function(ns["id"], function_name)
+            if fn:
+                if function:
+                    raise click.ClickException(
+                        f"Function '{function_name}' exists in multiple namespaces; use --namespace"
+                    )
+                function = fn
+
+    if not function:
+        raise click.ClickException(
+            f"Function '{function_name}' not found. Create it first with `granny serverless create-function`."
+        )
+
+    click.echo(f"Target: {function['name']} (id={function['id']})")
+
+    # Merge env/secret inputs
+    env_vars = _parse_env_pairs(env_pairs)
+    secrets = _parse_secret_pairs(secret_pairs)
+    if env_json:
+        payload = json.loads(Path(env_json).read_text())
+        env_vars.update(payload.get("env", {}))
+        secrets.extend(payload.get("secrets", []))
+
+    # Package + deploy
+    with tempfile.TemporaryDirectory() as tmp:
+        zip_path = Path(tmp) / f"{function_name}.zip"
+        click.echo(f"Packaging {source_dir} -> {zip_path.name}")
+        _zip_package(source_dir, zip_path)
+        size_mb = zip_path.stat().st_size / 1024 / 1024
+        click.echo(f"Package size: {size_mb:.1f} MB")
+        if size_mb > 80:
+            click.echo("WARN: package > 80 MB (Scaleway limit is 100 MB)", err=True)
+
+        result = c.deploy_package(
+            function["id"],
+            str(zip_path),
+            env=env_vars or None,
+            secrets=secrets or None,
+        )
+
+    status = result.get("status", "unknown")
+    click.echo(f"Deploy initiated: status={status}")
+    if result.get("domain_name"):
+        click.echo(f"Endpoint: https://{result['domain_name']}")
+    if status not in ("pending", "ready", "creating"):
+        sys.exit(1)