wxcli 1.2.0__py3-none-any.whl

wxcli/commands/hybrid_connectors.py

@@ -0,0 +1,67 @@
+import json
+import typer
+from wxcli.auth import get_api
+from wxcli.errors import WebexError, handle_rest_error
+from wxcli.output import print_table, print_json
+from wxcli.config import get_org_id
+
+
+app = typer.Typer(help="Manage Webex Calling hybrid-connectors.")
+
+
+@app.command("list")
+def cmd_list(
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Hybrid Connectors."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/hybrid/connectors"
+    params = {}
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[("ID", "id"), ("Name", "name")], limit=limit)
+
+
+
+@app.command("show")
+def show(
+    connector_id: str = typer.Argument(help="connectorId"),
+    output: str = typer.Option("json", "--output", "-o", help="Output format: table|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Hybrid Connector Details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/hybrid/connectors/{connector_id}"
+    try:
+        result = api.session.rest_get(url)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    else:
+        if isinstance(result, dict):
+            print_table([result], columns=[("Key", ""), ("Value", "")], limit=0)
+        elif isinstance(result, list):
+            print_table(result, columns=[("ID", "id"), ("Name", "name")], limit=0)
+        else:
+            print_json(result)
+
+

wxcli/commands/identity_org.py

@@ -0,0 +1,159 @@
+import json
+import typer
+from wxcli.auth import get_api
+from wxcli.errors import WebexError, handle_rest_error
+from wxcli.output import print_table, print_json
+from wxcli.config import resolve_org_id
+
+
+app = typer.Typer(help="Manage Webex Calling identity-org.")
+
+
+@app.command("show")
+def show(
+    output: str = typer.Option("json", "--output", "-o", help="Output format: table|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get an organization."""
+    api = get_api(debug=debug)
+    org_id = resolve_org_id(api.session)
+    url = f"https://webexapis.com/identity/organizations/{org_id}"
+    try:
+        result = api.session.rest_get(url)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    else:
+        if isinstance(result, dict):
+            print_table([result], columns=[("Key", ""), ("Value", "")], limit=0)
+        elif isinstance(result, list):
+            print_table(result, columns=[("ID", "id"), ("Name", "name")], limit=0)
+        else:
+            print_json(result)
+
+
+
+@app.command("update")
+def update(
+    display_name: str = typer.Option(None, "--display-name", help="New full name of the organization."),
+    preferred_language: str = typer.Option(None, "--preferred-language", help="It is the default preferredLanguage for user creation in thi"),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Update an organization\n\nExample --json-body:\n  '{"schemas":["..."],"displayName":"...","preferredLanguage":"..."}'."""
+    api = get_api(debug=debug)
+    org_id = resolve_org_id(api.session)
+    url = f"https://webexapis.com/identity/organizations/{org_id}"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if display_name is not None:
+            body["displayName"] = display_name
+        if preferred_language is not None:
+            body["preferredLanguage"] = preferred_language
+    try:
+        result = api.session.rest_patch(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    typer.echo(f"Updated.")
+
+
+
+@app.command("update-authentication-config")
+def update_authentication_config(
+    remember_my_login_id: bool = typer.Option(None, "--remember-my-login-id/--no-remember-my-login-id", help="Login Id set to true if it should be remembered."),
+    remember_my_login_id_duration: str = typer.Option(None, "--remember-my-login-id-duration", help="Specifies the number of days the user's login ID is remember"),
+    mfa_enabled: bool = typer.Option(None, "--mfa-enabled/--no-mfa-enabled", help="Enable/ Disable multi-factor authentication on an organizati"),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Update Organization Authentication Configuration Settings\n\nExample --json-body:\n  '{"schemas":["..."],"RememberMyLoginId":true,"RememberMyLoginIdDuration":0,"mfaEnabled":true}'."""
+    api = get_api(debug=debug)
+    org_id = resolve_org_id(api.session)
+    url = f"https://webexapis.com/identity/organizations/{org_id}/authenticationConfig"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if remember_my_login_id is not None:
+            body["RememberMyLoginId"] = remember_my_login_id
+        if remember_my_login_id_duration is not None:
+            body["RememberMyLoginIdDuration"] = remember_my_login_id_duration
+        if mfa_enabled is not None:
+            body["mfaEnabled"] = mfa_enabled
+    try:
+        result = api.session.rest_patch(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    typer.echo(f"Updated.")
+
+
+
+@app.command("update-password-policy")
+def update_password_policy(
+    minimum_numeric: str = typer.Option(None, "--minimum-numeric", help="Minimum number of numeric characters in password"),
+    minimum_cap_alpha: str = typer.Option(None, "--minimum-cap-alpha", help="Minimum number of uppercase alphabetic character letters in"),
+    minimum_low_alpha: str = typer.Option(None, "--minimum-low-alpha", help="Minimum number of lowercase alphabetic character letters in"),
+    minimum_special: str = typer.Option(None, "--minimum-special", help="Minimum number of special characters included \"~!@#$%^&*()-_"),
+    minimum_length: str = typer.Option(None, "--minimum-length", help="Minimum length of password. Must be between 8 and 256, inclu"),
+    history_count: str = typer.Option(None, "--history-count", help="The number of former passwords in history, the new password"),
+    max_password_age: str = typer.Option(None, "--max-password-age", help="The password expired time, unit: day, that means user need t"),
+    not_acceptable_strings: str = typer.Option(None, "--not-acceptable-strings", help="The password can not be any one in this string list."),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Update Organization Password Policy\n\nExample --json-body:\n  '{"schemas":["..."],"minimumNumeric":"...","minimumCapAlpha":"...","minimumLowAlpha":"...","minimumSpecial":"...","minimumLength":"...","historyCount":"...","maxPasswordAge":"..."}'."""
+    api = get_api(debug=debug)
+    org_id = resolve_org_id(api.session)
+    url = f"https://webexapis.com/identity/organizations/{org_id}/passwordPolicy"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if minimum_numeric is not None:
+            body["minimumNumeric"] = minimum_numeric
+        if minimum_cap_alpha is not None:
+            body["minimumCapAlpha"] = minimum_cap_alpha
+        if minimum_low_alpha is not None:
+            body["minimumLowAlpha"] = minimum_low_alpha
+        if minimum_special is not None:
+            body["minimumSpecial"] = minimum_special
+        if minimum_length is not None:
+            body["minimumLength"] = minimum_length
+        if history_count is not None:
+            body["historyCount"] = history_count
+        if max_password_age is not None:
+            body["maxPasswordAge"] = max_password_age
+        if not_acceptable_strings is not None:
+            body["notAcceptableStrings"] = not_acceptable_strings
+    try:
+        result = api.session.rest_patch(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    typer.echo(f"Updated.")
+
+
+
+@app.command("generate-otp")
+def generate_otp(
+    user_id: str = typer.Argument(help="userId"),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Generate OTP."""
+    api = get_api(debug=debug)
+    org_id = resolve_org_id(api.session)
+    url = f"https://webexapis.com/identity/organizations/{org_id}/users/{user_id}/actions/generateOtp"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+    try:
+        result = api.session.rest_post(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    print_json(result)
+
+

wxcli/commands/init_playbook.py

@@ -0,0 +1,155 @@
+"""wxcli init — materialize the bundled Claude Code playbook into a local folder.
+
+The folder layout mirrors the repo (CLAUDE.md, .claude/, docs/reference/), so
+Claude Code loads everything natively and no path is rewritten (spec §4.3).
+A manifest records every written file; refresh and --uninstall touch ONLY
+manifest-owned paths — user files are never clobbered.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+import typer
+
+import wxcli
+from wxcli import __version__
+
+app = typer.Typer(help="Materialize the bundled Claude Code playbook into a local project folder.")
+
+MANIFEST_REL = Path(".claude") / ".wxops-manifest.json"
+
+
+def bundle_root() -> Path:
+    """The playbook shipped inside the installed package (test-injectable)."""
+    return Path(wxcli.__file__).resolve().parent / "_playbook"
+
+
+def read_bundle(bundle: Path) -> dict[str, bytes]:
+    """posix relpath -> content for every file in the installed bundle."""
+    return {
+        p.relative_to(bundle).as_posix(): p.read_bytes()
+        for p in sorted(bundle.rglob("*")) if p.is_file()
+    }
+
+
+def sha256_hex(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def load_manifest(folder: Path) -> dict | None:
+    path = folder / MANIFEST_REL
+    return json.loads(path.read_text()) if path.exists() else None
+
+
+def save_manifest(folder: Path, hashes: dict[str, str]) -> None:
+    path = folder / MANIFEST_REL
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(
+        {"wxops_playbook": True, "version": __version__, "files": hashes}, indent=2
+    ))
+
+
+def _prune_empty_dirs(start: Path, stop: Path) -> None:
+    d = start
+    while d != stop and d.is_dir():
+        try:
+            d.rmdir()          # fails (OSError) if non-empty → stop pruning
+        except OSError:
+            return
+        d = d.parent
+
+
+def apply_bundle(
+    folder: Path, bundle_files: dict[str, bytes], owned: dict[str, str]
+) -> tuple[list[str], list[str], dict[str, str]]:
+    """Write/refresh the bundle. Returns (written, deleted, new_hashes).
+
+    Deletes manifest-owned paths absent from the new bundle (retired skills
+    don't linger); never touches paths it doesn't own (spec §4.3).
+    """
+    written: list[str] = []
+    hashes: dict[str, str] = {}
+    for rel, content in bundle_files.items():
+        dest = folder / rel
+        if not dest.exists() or dest.read_bytes() != content:
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            dest.write_bytes(content)
+            written.append(rel)
+        hashes[rel] = sha256_hex(content)
+    deleted: list[str] = []
+    for rel in sorted(set(owned) - set(bundle_files)):
+        target = folder / rel
+        if target.exists():
+            target.unlink()
+        deleted.append(rel)
+        _prune_empty_dirs(target.parent, folder)
+    return written, deleted, hashes
+
+
+def do_uninstall(folder: Path) -> None:
+    manifest = load_manifest(folder)
+    if manifest is None:
+        typer.echo(f"No wxops manifest in {folder} — nothing to uninstall.", err=True)
+        raise typer.Exit(1)
+    for rel in sorted(manifest.get("files", {})):
+        target = folder / rel
+        if target.exists():
+            target.unlink()
+        _prune_empty_dirs(target.parent, folder)
+    (folder / MANIFEST_REL).unlink(missing_ok=True)
+    _prune_empty_dirs((folder / MANIFEST_REL).parent, folder)
+    typer.echo(f"Removed the wxops playbook from {folder}. Files you added were left in place.")
+
+
+# A single @app.command() with no callback: Typer collapses the app into this
+# command, so `wxcli init FOLDER --flags` parses positionals and options together.
+# (A group callback would treat post-positional options as subcommand names.)
+@app.command()
+def init(
+    folder: Path = typer.Argument(Path("wxcli-playbook"), help="Target playbook folder."),
+    force: bool = typer.Option(False, "--force", help="Overwrite collisions / refresh without prompting."),
+    yes: bool = typer.Option(False, "--yes", help="Skip the confirmation prompt."),
+    uninstall: bool = typer.Option(False, "--uninstall", help="Remove every manifest-owned file, then the manifest."),
+):
+    """Materialize the bundled playbook (CLAUDE.md, .claude/, docs/reference/) into FOLDER."""
+    folder = folder.resolve()
+    if uninstall:
+        do_uninstall(folder)
+        return
+
+    bundle = bundle_root()
+    if not bundle.is_dir():
+        typer.echo("Bundled playbook not found in this wxcli install.", err=True)
+        raise typer.Exit(1)
+    bundle_files = read_bundle(bundle)
+    manifest = load_manifest(folder)
+
+    if manifest is None:
+        collisions = sorted(rel for rel in bundle_files if (folder / rel).exists())
+        if collisions and not force:
+            typer.echo(f"{folder} already contains files the playbook would overwrite:", err=True)
+            for rel in collisions:
+                typer.echo(f"  {rel}", err=True)
+            typer.echo("Re-run with --force to overwrite them, or choose an empty folder.", err=True)
+            raise typer.Exit(1)
+        owned: dict[str, str] = {}
+    else:
+        owned = manifest.get("files", {})
+        if not (force or yes) and not typer.confirm(
+            f"Refresh the wxops playbook in {folder} (owned files only)?"
+        ):
+            raise typer.Exit(0)
+
+    folder.mkdir(parents=True, exist_ok=True)
+    written, deleted, hashes = apply_bundle(folder, bundle_files, owned)
+    save_manifest(folder, hashes)
+    typer.echo(
+        f"Playbook v{__version__}: {len(written)} file(s) written, "
+        f"{len(deleted)} removed, in {folder}"
+    )
+    typer.echo(
+        "Open this folder in Claude Code (start a fresh session) — "
+        "skills and agents load at session start."
+    )

wxcli/commands/licenses.py

@@ -0,0 +1,106 @@
+import json
+import typer
+from wxcli.auth import get_api
+from wxcli.errors import WebexError, handle_rest_error
+from wxcli.output import print_table, print_json
+from wxcli.config import get_org_id
+
+
+app = typer.Typer(help="Manage Webex Calling licenses.")
+
+
+@app.command("list")
+def cmd_list(
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Licenses."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/licenses"
+    params = {}
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    org_id = get_org_id()
+    if org_id is not None:
+        params["orgId"] = org_id
+    result = None
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    result = result or []
+    items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[('ID', 'id'), ('Name', 'name'), ('Total Units', 'totalUnits'), ('Consumed', 'consumedUnits')], limit=limit)
+
+
+
+@app.command("show")
+def show(
+    license_id: str = typer.Argument(help="licenseId"),
+    include_assigned_to: str = typer.Option(None, "--include-assigned-to", help="Choices: user"),
+    next: str = typer.Option(None, "--next", help="List the next set of users. Applicable only if `includeAssig"),
+    limit: str = typer.Option(None, "--limit", help="A limit on the number of users to be returned in the respons"),
+    output: str = typer.Option("json", "--output", "-o", help="Output format: table|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get License Details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/licenses/{license_id}"
+    params = {}
+    if include_assigned_to is not None:
+        params["includeAssignedTo"] = include_assigned_to
+    if next is not None:
+        params["next"] = next
+    if limit is not None:
+        params["limit"] = limit
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    else:
+        if isinstance(result, dict):
+            print_table([result], columns=[("Key", ""), ("Value", "")], limit=0)
+        elif isinstance(result, list):
+            print_table(result, columns=[("ID", "id"), ("Name", "name")], limit=0)
+        else:
+            print_json(result)
+
+
+
+@app.command("update")
+def update(
+    email: str = typer.Option(None, "--email", help="Email address of the user."),
+    person_id: str = typer.Option(None, "--person-id", help="A unique identifier for the user."),
+    org_id: str = typer.Option(None, "--org-id", help="The ID of the organization to which the licenses and siteUrl"),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Assign Licenses to Users\n\nExample --json-body:\n  '{"email":"...","personId":"...","orgId":"...","licenses":[{"id":"...","operation":"...","properties":"..."}],"siteUrls":[{"siteUrl":"...","accountType":"...","operation":"..."}]}'."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/licenses/users"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if email is not None:
+            body["email"] = email
+        if person_id is not None:
+            body["personId"] = person_id
+        if org_id is not None:
+            body["orgId"] = org_id
+    try:
+        result = api.session.rest_patch(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    typer.echo(f"Updated.")
+
+

wxcli/commands/live_monitoring.py

@@ -0,0 +1,40 @@
+import json
+import typer
+from wxcli.auth import get_api
+from wxcli.errors import WebexError, handle_rest_error
+from wxcli.output import print_table, print_json
+
+
+app = typer.Typer(help="Manage Webex Calling live-monitoring.")
+
+
+@app.command("create")
+def create(
+    site_url: str = typer.Option(None, "--site-url", help="A site URL."),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    output: str = typer.Option("id", "--output", "-o", help="Output format: id|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Live Meeting metrics categorized by Country\n\nExample --json-body:\n  '{"siteIds":[0],"siteUrl":"..."}'."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/livemonitoring/liveMeetingsByCountry"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if site_url is not None:
+            body["siteUrl"] = site_url
+    try:
+        result = api.session.rest_post(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    elif isinstance(result, dict) and "id" in result:
+        typer.echo(f"Created: {result['id']}")
+    elif not result or result == {}:
+        typer.echo("Created.")
+    else:
+        print_json(result)
+
+