nexla-cli 0.2.0__py3-none-any.whl

nexla_cli/resources/credentials.py

@@ -0,0 +1,130 @@
+"""`nexla credentials` — list / get / create / update / delete.
+
+Mirrors ``routers/nexla_agent_api/credentials.py``.
+"""
+
+from __future__ import annotations
+
+import json as jsonlib
+
+import typer
+
+from .. import client, dryrun, output, validate
+
+app = typer.Typer(name="credentials", help="Manage Nexla credentials.", no_args_is_help=True)
+
+_COLUMNS = ["id", "name", "connector", "kind", "auth_mode"]
+
+_JSON_OPT = typer.Option(
+    None, "--json", help="Raw JSON body; merged under named options, over --params"
+)
+_PARAMS_OPT = typer.Option(
+    [], "--params", help="key=value body overrides (repeatable); lowest precedence"
+)
+_DRY_RUN_OPT = typer.Option(
+    False, "--dry-run", help="Validate locally against the live schema; fire no mutating call"
+)
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    connector: str | None = typer.Option(None),
+    kind: str | None = typer.Option(None),
+    access_role: str = typer.Option("collaborator"),
+    page: int = typer.Option(1),
+    per_page: int = typer.Option(50),
+) -> None:
+    """List credentials."""
+    params: dict[str, object] = {"access_role": access_role, "page": page, "per_page": per_page}
+    if connector is not None:
+        params["connector"] = connector
+    if kind is not None:
+        params["kind"] = kind
+    if output.ctx_page_all(ctx):
+        filters = {k: v for k, v in params.items() if k not in ("page", "per_page")}
+        for item in client.paginate("/nexla/credentials", params=filters, per_page=per_page):
+            output.emit(item, mode="ndjson", fields=output.ctx_fields(ctx))
+        return
+    output.emit(
+        client.request("GET", "/nexla/credentials", params=params),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+        columns=_COLUMNS,
+    )
+
+
+@app.command("get")
+def get(ctx: typer.Context, credential_id: int) -> None:
+    """Get one credential by id."""
+    output.emit(
+        client.request("GET", f"/nexla/credentials/{credential_id}"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("create")
+def create(
+    ctx: typer.Context,
+    name: str = typer.Option(...),
+    connector: str = typer.Option(...),
+    description: str | None = typer.Option(None),
+    auth_mode: str | None = typer.Option(None),
+    config: str = typer.Option("{}", help="JSON object of connector-specific fields"),
+    json_body: str | None = _JSON_OPT,
+    params: list[str] = _PARAMS_OPT,
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Create a credential."""
+    named: dict[str, object] = {
+        "name": name,
+        "connector": connector,
+        "description": description,
+        "auth_mode": auth_mode,
+        "config": jsonlib.loads(config) if config != "{}" else None,
+    }
+    body = validate.build_body(named, json_body, params)
+    if dry_run:
+        dryrun.run_dry_run(resource="credentials", verb="create", body=body)
+    output.emit(
+        client.request("POST", "/nexla/credentials", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("update")
+def update(
+    ctx: typer.Context,
+    credential_id: int,
+    name: str | None = typer.Option(None),
+    description: str | None = typer.Option(None),
+    config: str | None = typer.Option(None, help="JSON object"),
+    json_body: str | None = _JSON_OPT,
+    params: list[str] = _PARAMS_OPT,
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Update a credential."""
+    named: dict[str, object] = {
+        "name": name,
+        "description": description,
+        "config": jsonlib.loads(config) if config is not None else None,
+    }
+    body = validate.build_body(named, json_body, params)
+    if dry_run:
+        dryrun.run_dry_run(resource="credentials", verb="update", body=body)
+    output.emit(
+        client.request("PATCH", f"/nexla/credentials/{credential_id}", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("delete")
+def delete(credential_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Delete a credential."""
+    if dry_run:
+        dryrun.run_dry_run(resource="credentials", verb="delete", body={})
+    client.request("DELETE", f"/nexla/credentials/{credential_id}")
+    typer.echo(f"deleted credential {credential_id}")

nexla_cli/resources/flows.py

@@ -0,0 +1,90 @@
+"""`nexla flows` — list / get / activate / pause / delete.
+
+Mirrors ``routers/nexla_agent_api/flows.py``. No create/update — flows are
+assembled implicitly from source/nexset/sink creation.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .. import client, dryrun, output
+
+app = typer.Typer(name="flows", help="Manage Nexla flows.", no_args_is_help=True)
+
+_COLUMNS = ["id", "name", "status", "source_connector"]
+
+_DRY_RUN_OPT = typer.Option(
+    False, "--dry-run", help="Validate locally against the live schema; fire no mutating call"
+)
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    status_: str | None = typer.Option(None, "--status"),
+    q: str | None = typer.Option(None),
+    access_role: str = typer.Option("collaborator"),
+    page: int = typer.Option(1),
+    per_page: int = typer.Option(50),
+) -> None:
+    """List flows."""
+    params: dict[str, object] = {"access_role": access_role, "page": page, "per_page": per_page}
+    if status_ is not None:
+        params["status"] = status_
+    if q is not None:
+        params["q"] = q
+    if output.ctx_page_all(ctx):
+        filters = {k: v for k, v in params.items() if k not in ("page", "per_page")}
+        for item in client.paginate("/nexla/flows", params=filters, per_page=per_page):
+            output.emit(item, mode="ndjson", fields=output.ctx_fields(ctx))
+        return
+    output.emit(
+        client.request("GET", "/nexla/flows", params=params),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+        columns=_COLUMNS,
+    )
+
+
+@app.command("get")
+def get(ctx: typer.Context, flow_id: int) -> None:
+    """Get one flow, including its full DAG."""
+    output.emit(
+        client.request("GET", f"/nexla/flows/{flow_id}"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("activate")
+def activate(ctx: typer.Context, flow_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Activate a flow."""
+    if dry_run:
+        dryrun.run_dry_run(resource="flows", verb="activate", body={})
+    output.emit(
+        client.request("PUT", f"/nexla/flows/{flow_id}/activate"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("pause")
+def pause(ctx: typer.Context, flow_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Pause a flow."""
+    if dry_run:
+        dryrun.run_dry_run(resource="flows", verb="pause", body={})
+    output.emit(
+        client.request("PUT", f"/nexla/flows/{flow_id}/pause"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("delete")
+def delete(flow_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Delete a flow."""
+    if dry_run:
+        dryrun.run_dry_run(resource="flows", verb="delete", body={})
+    client.request("DELETE", f"/nexla/flows/{flow_id}")
+    typer.echo(f"deleted flow {flow_id}")

nexla_cli/resources/mcp_servers.py

@@ -0,0 +1,103 @@
+"""`nexla mcp-servers` — external MCP servers nested under a toolset.
+
+Mirrors ``routers/nexla_agent_api/mcp_servers.py``
+(``/nexla/toolsets/{toolset_id}/mcp-servers/*``). No update — attach again
+with a new name or detach + reattach.
+"""
+
+from __future__ import annotations
+
+import json as jsonlib
+
+import typer
+
+from .. import client, dryrun, output, validate
+
+app = typer.Typer(
+    name="mcp-servers", help="Manage external MCP servers on a toolset's gateway.", no_args_is_help=True
+)
+
+_COLUMNS = ["id", "toolset_id", "server_name", "server_url", "status", "tool_count"]
+
+_JSON_OPT = typer.Option(
+    None, "--json", help="Raw JSON body; merged under named options, over --params"
+)
+_PARAMS_OPT = typer.Option(
+    [], "--params", help="key=value body overrides (repeatable); lowest precedence"
+)
+_DRY_RUN_OPT = typer.Option(
+    False, "--dry-run", help="Validate locally against the live schema; fire no mutating call"
+)
+
+
+@app.command("list")
+def list_(ctx: typer.Context, toolset_id: int) -> None:
+    """List MCP servers on a toolset."""
+    # No page/per_page on this endpoint — always a single response, not a
+    # Page[T] envelope, so --page-all does not apply here.
+    output.emit(
+        client.request("GET", f"/nexla/toolsets/{toolset_id}/mcp-servers"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+        columns=_COLUMNS,
+    )
+
+
+@app.command("attach")
+def attach(
+    ctx: typer.Context,
+    toolset_id: int,
+    server_name: str = typer.Option(...),
+    server_url: str = typer.Option(...),
+    server_description: str | None = typer.Option(None),
+    auth_type: str | None = typer.Option(None, help="'bearer' | 'basic' | 'headers' | 'none'"),
+    auth_value: str | None = typer.Option(
+        None, help="Bearer/basic token string, or JSON object for 'headers'"
+    ),
+    tool_filter: str | None = typer.Option(None, help="JSON object {mode, tool_names, patterns}"),
+    json_body: str | None = _JSON_OPT,
+    params: list[str] = _PARAMS_OPT,
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Attach an external MCP server to a toolset."""
+    named: dict[str, object] = {
+        "server_name": server_name,
+        "server_description": server_description,
+        "server_url": server_url,
+    }
+    if auth_type is not None:
+        value: object = auth_value
+        if auth_type == "headers" and auth_value is not None:
+            value = jsonlib.loads(auth_value)
+        named["auth"] = {"type": auth_type, "value": value}
+    if tool_filter is not None:
+        named["tool_filter"] = jsonlib.loads(tool_filter)
+    body = validate.build_body(named, json_body, params)
+    if dry_run:
+        dryrun.run_dry_run(resource="mcp-servers", verb="attach", body=body)
+    output.emit(
+        client.request("POST", f"/nexla/toolsets/{toolset_id}/mcp-servers", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("sync")
+def sync(ctx: typer.Context, toolset_id: int, server_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Trigger discovery/indexing on an attached MCP server."""
+    if dry_run:
+        dryrun.run_dry_run(resource="mcp-servers", verb="sync", body={})
+    output.emit(
+        client.request("POST", f"/nexla/toolsets/{toolset_id}/mcp-servers/{server_id}/sync"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("detach")
+def detach(toolset_id: int, server_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Detach an MCP server from a toolset."""
+    if dry_run:
+        dryrun.run_dry_run(resource="mcp-servers", verb="detach", body={})
+    client.request("DELETE", f"/nexla/toolsets/{toolset_id}/mcp-servers/{server_id}")
+    typer.echo(f"detached mcp server {server_id} from toolset {toolset_id}")

nexla_cli/resources/metrics.py

@@ -0,0 +1,47 @@
+"""`nexla metrics` — thin, 501 passthrough.
+
+Mirrors ``routers/nexla_agent_api/metrics.py``.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .. import client, output, validate
+
+app = typer.Typer(name="metrics", help="Query Nexla metrics (not implemented in v1).", no_args_is_help=True)
+
+
+@app.command("catalog")
+def catalog(ctx: typer.Context) -> None:
+    """List available metric types. (Not implemented in v1.)"""
+    output.emit(
+        client.request("GET", "/nexla/metrics/catalog"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("for-resource")
+def for_resource(ctx: typer.Context, resource_type: str, resource_id: str) -> None:
+    """Get all metrics for a resource. (Not implemented in v1.)"""
+    resource_type = validate.resource_id(resource_type)
+    resource_id = validate.resource_id(resource_id)
+    output.emit(
+        client.request("GET", f"/nexla/metrics/{resource_type}/{resource_id}"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("get")
+def get(ctx: typer.Context, resource_type: str, resource_id: str, metric_type: str) -> None:
+    """Get one metric for a resource. (Not implemented in v1.)"""
+    resource_type = validate.resource_id(resource_type)
+    resource_id = validate.resource_id(resource_id)
+    metric_type = validate.resource_id(metric_type)
+    output.emit(
+        client.request("GET", f"/nexla/metrics/{resource_type}/{resource_id}/{metric_type}"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )

nexla_cli/resources/nexsets.py

@@ -0,0 +1,110 @@
+"""`nexla nexsets` — list / get / transform / activate.
+
+No update/delete — nexsets are source-spawned or transform-derived only.
+Mirrors ``routers/nexla_agent_api/nexsets.py``.
+"""
+
+from __future__ import annotations
+
+import json as jsonlib
+
+import typer
+
+from .. import client, dryrun, output, validate
+
+app = typer.Typer(name="nexsets", help="Manage Nexla nexsets.", no_args_is_help=True)
+
+_COLUMNS = ["id", "name", "status", "flow_id", "parent_nexset_id"]
+
+_JSON_OPT = typer.Option(
+    None, "--json", help="Raw JSON body; merged under named options, over --params"
+)
+_PARAMS_OPT = typer.Option(
+    [], "--params", help="key=value body overrides (repeatable); lowest precedence"
+)
+_DRY_RUN_OPT = typer.Option(
+    False, "--dry-run", help="Validate locally against the live schema; fire no mutating call"
+)
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    flow_id: int | None = typer.Option(None),
+    parent_id: int | None = typer.Option(None),
+    access_role: str = typer.Option("collaborator"),
+    page: int = typer.Option(1),
+    per_page: int = typer.Option(50),
+) -> None:
+    """List nexsets."""
+    params: dict[str, object] = {"access_role": access_role, "page": page, "per_page": per_page}
+    if flow_id is not None:
+        params["flow_id"] = flow_id
+    if parent_id is not None:
+        params["parent_id"] = parent_id
+    if output.ctx_page_all(ctx):
+        filters = {k: v for k, v in params.items() if k not in ("page", "per_page")}
+        for item in client.paginate("/nexla/nexsets", params=filters, per_page=per_page):
+            output.emit(item, mode="ndjson", fields=output.ctx_fields(ctx))
+        return
+    output.emit(
+        client.request("GET", "/nexla/nexsets", params=params),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+        columns=_COLUMNS,
+    )
+
+
+@app.command("get")
+def get(ctx: typer.Context, nexset_id: int) -> None:
+    """Get one nexset, including samples and schema."""
+    output.emit(
+        client.request("GET", f"/nexla/nexsets/{nexset_id}"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("transform")
+def transform(
+    ctx: typer.Context,
+    parent_id: int,
+    name: str = typer.Option(...),
+    language: str = typer.Option(..., help="'python' or 'sql'"),
+    code: str = typer.Option(...),
+    description: str | None = typer.Option(None),
+    options: str | None = typer.Option(None, help="JSON object (SQL only)"),
+    auto_activate: bool = typer.Option(True),
+    json_body: str | None = _JSON_OPT,
+    params: list[str] = _PARAMS_OPT,
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Derive a child nexset via a Python/SQL transform."""
+    named: dict[str, object] = {
+        "name": name,
+        "description": description,
+        "language": language,
+        "code": code,
+        "options": jsonlib.loads(options) if options is not None else None,
+        "auto_activate": auto_activate,
+    }
+    body = validate.build_body(named, json_body, params)
+    if dry_run:
+        dryrun.run_dry_run(resource="nexsets", verb="transform", body=body)
+    output.emit(
+        client.request("POST", f"/nexla/nexsets/{parent_id}/transform", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("activate")
+def activate(ctx: typer.Context, nexset_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Activate a nexset."""
+    if dry_run:
+        dryrun.run_dry_run(resource="nexsets", verb="activate", body={})
+    output.emit(
+        client.request("PUT", f"/nexla/nexsets/{nexset_id}/activate"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )

nexla_cli/resources/notifications.py

@@ -0,0 +1,24 @@
+"""`nexla notifications` — thin, 501 passthrough.
+
+Mirrors ``routers/nexla_agent_api/notifications.py``.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .. import client, output
+
+app = typer.Typer(
+    name="notifications", help="List notifications (not implemented in v1).", no_args_is_help=True
+)
+
+
+@app.command("list")
+def list_(ctx: typer.Context) -> None:
+    """List notifications. (Not implemented in v1.)"""
+    output.emit(
+        client.request("GET", "/nexla/notifications"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )

nexla_cli/resources/orgs.py

@@ -0,0 +1,53 @@
+"""`nexla orgs` — list (real) / get (501).
+
+Mirrors ``routers/nexla_agent_api/orgs.py``. ``list`` proxies a real,
+working endpoint (a bare array, not a ``Page[T]`` envelope) and gets the
+same full treatment as any other resource for ``--output``/``--fields``;
+only ``get`` 501s.
+
+**``--page-all`` is explicitly rejected here**, not silently ignored.
+``list`` takes no ``page``/``per_page`` params and the upstream endpoint
+returns a bare array with no ``items``/``next_page`` keys, so
+``client.paginate()`` cannot be wired against it (it would try to read
+those keys off a list and break). Per the phase-2 plan's stuck-resource
+policy (pick the more conservative option when forced to choose between
+reject-with-error and silent-ignore), an explicit ``CliError`` is raised
+instead of quietly doing the wrong thing.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .. import client, output
+from ..errors import EXIT, CliError
+
+app = typer.Typer(name="orgs", help="Manage Nexla orgs.", no_args_is_help=True)
+
+_COLUMNS = ["id", "name"]
+
+
+@app.command("list")
+def list_(ctx: typer.Context) -> None:
+    """List orgs."""
+    if output.ctx_page_all(ctx):
+        raise CliError(
+            EXIT.VALIDATION,
+            "orgs list does not support --page-all (bare-array endpoint, no next_page)",
+        )
+    output.emit(
+        client.request("GET", "/nexla/orgs"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+        columns=_COLUMNS,
+    )
+
+
+@app.command("get")
+def get(ctx: typer.Context, org_id: int) -> None:
+    """Get one org by id."""
+    output.emit(
+        client.request("GET", f"/nexla/orgs/{org_id}"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )

nexla_cli/resources/probe.py

@@ -0,0 +1,94 @@
+"""`nexla probe` — probe a credential or inline config.
+
+Mirrors ``routers/nexla_agent_api/probe.py``: one action-discriminated
+endpoint covering validate/tree/sample. Exactly one of
+``--credential-id``/``--connector`` must be given.
+"""
+
+from __future__ import annotations
+
+import json as jsonlib
+import re
+
+import typer
+
+from .. import client, output
+from ..errors import CliError
+
+app = typer.Typer(name="probe", help="Probe a Nexla credential or inline config.", no_args_is_help=True)
+
+# ``--params`` is a free-form, kind-discriminated bag on the server side --
+# the shape that's valid depends entirely on the connector's `kind`
+# (surfaced by `nexla connectors search <name>`/`describe <name>`), and
+# nothing in the live OpenAPI schema documents it (it's typed as a bare
+# `additionalProperties: true` object there). See AGENTS.md/SKILL.md
+# "probe params shape depends on connector kind" for the authoritative,
+# longer version of this -- keep the two in sync if this changes.
+_PARAMS_HELP = (
+    "JSON object of action params; shape depends on the connector's `kind` "
+    "(see `nexla connectors search <name>` for kind). api: "
+    '{"endpoint": "<connector>.<endpoint_id>", "config": {...}} (get '
+    "endpoint/field names from `describe-source`/`describe-source-endpoint`). "
+    'db: {"db_query_mode": "Default", "table": ..., "database": ...} or '
+    '{"db_query_mode": "Query", "query": ...}. file: {"path": ...} (required). '
+    'rest: {"url": ..., "method": "GET", "response.data.path": ...} or the '
+    'full passthrough {"rest.iterations": [...]}.'
+)
+
+# Java NPE-style messages the upstream probe service returns verbatim
+# (e.g. `Cannot read field "template" because "varInfo" is null`) when
+# `--params` doesn't match the connector's `kind` -- these pass through
+# `client.request` as an opaque 500 with no indication of the real cause.
+# Detecting the shape (rather than one exact message) survives the field
+# name varying per connector/kind.
+_NPE_SIGNATURE = re.compile(r"cannot read (field|property|array)|nullpointerexception", re.IGNORECASE)
+_NPE_HINT = (
+    "this looks like an upstream Java NPE, which usually means --params "
+    "doesn't match the connector's expected shape for its kind (api/db/file/"
+    "rest) -- run `nexla probe run --help` for the shape per kind"
+)
+
+
+def _annotate_npe(e: CliError, action: str) -> CliError:
+    """Append a shape-mismatch hint to `sample`/`tree` 500s that look like the
+    upstream NPE signature, without changing the exit code or envelope."""
+    if action not in ("sample", "tree"):
+        return e
+    envelope = e.envelope or {}
+    message = envelope.get("errorMessage") or envelope.get("error")
+    if not isinstance(message, str) or not _NPE_SIGNATURE.search(message):
+        return e
+    return CliError(e.code, f"{e.message}\nhint: {_NPE_HINT}", envelope=e.envelope)
+
+
+@app.command("run")
+def run(
+    ctx: typer.Context,
+    action: str = typer.Option(..., help="'validate', 'tree', or 'sample'"),
+    credential_id: int | None = typer.Option(None),
+    connector: str | None = typer.Option(None, help="Inline credential: connector name"),
+    auth_mode: str | None = typer.Option(None, help="Inline credential: auth mode"),
+    config: str = typer.Option("{}", help="Inline credential: JSON config"),
+    params: str = typer.Option("{}", help=_PARAMS_HELP),
+) -> None:
+    """Validate a credential, or sample/tree an endpoint."""
+    if (credential_id is None) == (connector is None):
+        raise typer.BadParameter("specify exactly one of --credential-id or --connector")
+    body: dict[str, object] = {"action": action, "params": jsonlib.loads(params)}
+    if credential_id is not None:
+        body["credential_id"] = credential_id
+    else:
+        body["credential"] = {
+            "connector": connector,
+            "auth_mode": auth_mode,
+            "config": jsonlib.loads(config),
+        }
+    try:
+        response = client.request("POST", "/nexla/probe", json=body)
+    except CliError as e:
+        raise _annotate_npe(e, action) from e
+    output.emit(
+        response,
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )