nexla-cli 0.2.0__py3-none-any.whl

nexla_cli/resources/sinks.py

@@ -0,0 +1,264 @@
+"""`nexla sinks` — list / get / create / update / activate / pause / delete.
+
+Mirrors ``routers/nexla_agent_api/sinks.py``. ``update`` maps to the
+router's pause→apply→reactivate ``PATCH`` cycle — the CLI just calls it,
+the API hides the mechanics.
+"""
+
+from __future__ import annotations
+
+import json as jsonlib
+
+import typer
+
+from .. import client, dryrun, output, validate
+from ..errors import EXIT, CliError
+
+app = typer.Typer(name="sinks", help="Manage Nexla data sinks.", no_args_is_help=True)
+
+_COLUMNS = ["id", "name", "status", "connector", "kind", "nexset_id", "flow_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"
+)
+_SKIP_TABLE_CHECK_OPT = typer.Option(
+    False,
+    "--skip-table-check",
+    help="Skip the pre-flight DB/JDBC target-table existence check",
+)
+
+# DB/JDBC-family connectors: `sinks create` does NOT auto-provision the
+# destination table (unlike sources). See AGENTS.md's "DB/JDBC sinks
+# require the target table to pre-exist". Used to gate the pre-flight
+# table check below -- not exhaustive, just the common ones.
+_DB_KIND_CONNECTORS = {
+    "postgres",
+    "postgresql",
+    "supabase",
+    "redshift",
+    "snowflake",
+    "mysql",
+    "mariadb",
+    "sqlserver",
+    "sql_server",
+    "oracle",
+    "db2",
+    "cockroachdb",
+    "teradata",
+    "singlestore",
+    "clickhouse",
+}
+
+
+def _probe_tree_names(credential_id: int) -> list[str] | None:
+    """Best-effort table/schema names from `probe run --action tree`.
+
+    Returns ``None`` if the probe call fails or nothing name-shaped comes
+    back -- callers must treat that as "couldn't check", never as "table
+    missing".
+    """
+    try:
+        resp = client.request(
+            "POST",
+            "/nexla/probe",
+            json={"action": "tree", "credential_id": credential_id, "params": {}},
+        )
+    except Exception:
+        return None
+
+    names: list[str] = []
+
+    def _walk(node: object) -> None:
+        if isinstance(node, dict):
+            for key in ("name", "table", "table_name"):
+                value = node.get(key)
+                if isinstance(value, str):
+                    names.append(value)
+            for value in node.values():
+                _walk(value)
+        elif isinstance(node, list):
+            for item in node:
+                _walk(item)
+
+    _walk(resp)
+    return names or None
+
+
+def _check_table_exists(credential_id: int, connector: str, config: object) -> None:
+    """Pre-flight for DB/JDBC sinks: warn or hard-fail if the target table is missing.
+
+    Best-effort only -- probes the credential's tree (same surface as
+    `nexla probe run --action tree`) and looks for the configured
+    ``table`` name among the returned nodes. Any failure or ambiguous
+    result (probe unsupported, empty tree, non-DB connector, no `table`
+    config key) degrades to a no-op or a warning; it never blocks. Only a
+    *confirmed* miss -- probe succeeded, returned names, table isn't among
+    them -- raises before the real `sinks create` call fires.
+    """
+    if connector.lower() not in _DB_KIND_CONNECTORS or not isinstance(config, dict):
+        return
+    table = config.get("table")
+    if not isinstance(table, str) or not table:
+        return
+
+    names = _probe_tree_names(credential_id)
+    if names is None:
+        typer.echo(
+            f"WARNING: could not verify table '{table}' exists (tried "
+            f"`nexla probe run --action tree --credential-id {credential_id}`). "
+            "DB/JDBC sinks do not auto-create the destination table -- confirm "
+            "it exists before this sink runs, or it will activate fine and then "
+            "stall in runtime_status: PROCESSING with no visible error.",
+            err=True,
+        )
+        return
+    if table not in names:
+        raise CliError(
+            EXIT.VALIDATION,
+            f"table '{table}' not found via `nexla probe run --action tree "
+            f"--credential-id {credential_id}`. Create it first (matching the "
+            "nexset's output_schema columns) or pass --skip-table-check if this "
+            "connector's tree probe is unreliable.",
+        )
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    connector: str | None = typer.Option(None),
+    nexset_id: int | None = typer.Option(None),
+    flow_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 sinks."""
+    params: dict[str, object] = {"access_role": access_role, "page": page, "per_page": per_page}
+    if connector is not None:
+        params["connector"] = connector
+    if nexset_id is not None:
+        params["nexset_id"] = nexset_id
+    if flow_id is not None:
+        params["flow_id"] = flow_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/sinks", params=filters, per_page=per_page):
+            output.emit(item, mode="ndjson", fields=output.ctx_fields(ctx))
+        return
+    output.emit(
+        client.request("GET", "/nexla/sinks", params=params),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+        columns=_COLUMNS,
+    )
+
+
+@app.command("get")
+def get(ctx: typer.Context, sink_id: int) -> None:
+    """Get one sink by id."""
+    output.emit(
+        client.request("GET", f"/nexla/sinks/{sink_id}"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("create")
+def create(
+    ctx: typer.Context,
+    name: str = typer.Option(...),
+    nexset_id: int = typer.Option(...),
+    credential_id: int = typer.Option(...),
+    connector: str = typer.Option(...),
+    endpoint: 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,
+    skip_table_check: bool = _SKIP_TABLE_CHECK_OPT,
+) -> None:
+    """Create and activate a sink."""
+    named: dict[str, object] = {
+        "name": name,
+        "nexset_id": nexset_id,
+        "credential_id": credential_id,
+        "connector": connector,
+        "endpoint": endpoint,
+        "config": jsonlib.loads(config) if config != "{}" else None,
+    }
+    body = validate.build_body(named, json_body, params)
+    if dry_run:
+        dryrun.run_dry_run(resource="sinks", verb="create", body=body)
+    if not skip_table_check:
+        _check_table_exists(credential_id, connector, body.get("config"))
+    output.emit(
+        client.request("POST", "/nexla/sinks", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("update")
+def update(
+    ctx: typer.Context,
+    sink_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 sink's name/description/config."""
+    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="sinks", verb="update", body=body)
+    output.emit(
+        client.request("PATCH", f"/nexla/sinks/{sink_id}", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("activate")
+def activate(ctx: typer.Context, sink_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Activate a paused sink."""
+    if dry_run:
+        dryrun.run_dry_run(resource="sinks", verb="activate", body={})
+    output.emit(
+        client.request("POST", f"/nexla/sinks/{sink_id}/activate"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("pause")
+def pause(ctx: typer.Context, sink_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Pause an active sink."""
+    if dry_run:
+        dryrun.run_dry_run(resource="sinks", verb="pause", body={})
+    output.emit(
+        client.request("POST", f"/nexla/sinks/{sink_id}/pause"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("delete")
+def delete(sink_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Delete a sink."""
+    if dry_run:
+        dryrun.run_dry_run(resource="sinks", verb="delete", body={})
+    client.request("DELETE", f"/nexla/sinks/{sink_id}")
+    typer.echo(f"deleted sink {sink_id}")

nexla_cli/resources/sources.py

@@ -0,0 +1,197 @@
+"""`nexla sources` — list / get / create / update / activate / pause / delete
+/ sample / file-upload.
+
+Mirrors ``routers/nexla_agent_api/sources.py``.
+"""
+
+from __future__ import annotations
+
+import json as jsonlib
+
+import typer
+
+from .. import client, dryrun, output, validate
+
+app = typer.Typer(name="sources", help="Manage Nexla data sources.", no_args_is_help=True)
+
+_COLUMNS = ["id", "name", "status", "connector", "kind", "flow_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,
+    connector: str | None = typer.Option(None),
+    flow_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 sources."""
+    params: dict[str, object] = {"access_role": access_role, "page": page, "per_page": per_page}
+    if connector is not None:
+        params["connector"] = connector
+    if flow_id is not None:
+        params["flow_id"] = flow_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/sources", params=filters, per_page=per_page):
+            output.emit(item, mode="ndjson", fields=output.ctx_fields(ctx))
+        return
+    output.emit(
+        client.request("GET", "/nexla/sources", params=params),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+        columns=_COLUMNS,
+    )
+
+
+@app.command("get")
+def get(ctx: typer.Context, source_id: int) -> None:
+    """Get one source by id."""
+    output.emit(
+        client.request("GET", f"/nexla/sources/{source_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),
+    credential_id: int | None = typer.Option(None),
+    endpoint: str | None = typer.Option(None),
+    mode: str | None = typer.Option(None, help="db connectors only: 'default' or 'query'"),
+    config: str = typer.Option("{}", help="JSON object of connector-specific fields"),
+    schedule: str = typer.Option("recurring", help="'recurring' or 'once'"),
+    json_body: str | None = _JSON_OPT,
+    params: list[str] = _PARAMS_OPT,
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Create and activate a source."""
+    named: dict[str, object] = {
+        "name": name,
+        "description": description,
+        "credential_id": credential_id,
+        "connector": connector,
+        "endpoint": endpoint,
+        "mode": mode,
+        "config": jsonlib.loads(config) if config != "{}" else None,
+        "schedule": schedule,
+    }
+    body = validate.build_body(named, json_body, params)
+    if dry_run:
+        dryrun.run_dry_run(resource="sources", verb="create", body=body)
+    output.emit(
+        client.request("POST", "/nexla/sources", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("update")
+def update(
+    ctx: typer.Context,
+    source_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 source's name/description/config."""
+    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="sources", verb="update", body=body)
+    output.emit(
+        client.request("PATCH", f"/nexla/sources/{source_id}", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("activate")
+def activate(ctx: typer.Context, source_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Activate a paused source."""
+    if dry_run:
+        dryrun.run_dry_run(resource="sources", verb="activate", body={})
+    output.emit(
+        client.request("POST", f"/nexla/sources/{source_id}/activate"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("pause")
+def pause(ctx: typer.Context, source_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Pause an active source."""
+    if dry_run:
+        dryrun.run_dry_run(resource="sources", verb="pause", body={})
+    output.emit(
+        client.request("POST", f"/nexla/sources/{source_id}/pause"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("delete")
+def delete(source_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Delete a source."""
+    if dry_run:
+        dryrun.run_dry_run(resource="sources", verb="delete", body={})
+    client.request("DELETE", f"/nexla/sources/{source_id}")
+    typer.echo(f"deleted source {source_id}")
+
+
+@app.command("sample")
+def sample(
+    ctx: typer.Context,
+    source_id: int,
+    payload: str = typer.Option(..., help="JSON payload to POST"),
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Post a sample payload to a webhook source."""
+    body = {"payload": jsonlib.loads(payload)}
+    if dry_run:
+        dryrun.run_dry_run(resource="sources", verb="sample", body=body)
+    output.emit(
+        client.request("POST", f"/nexla/sources/{source_id}/sample", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("file-upload")
+def file_upload(
+    ctx: typer.Context,
+    source_id: int,
+    path: list[str] = typer.Option(..., help="Absolute /workspace path; repeatable"),
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Push sandbox files to a file-upload source."""
+    body = {"files": [{"path": p} for p in path]}
+    if dry_run:
+        dryrun.run_dry_run(resource="sources", verb="file-upload", body=body)
+    output.emit(
+        client.request("POST", f"/nexla/sources/{source_id}/file_upload", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )

nexla_cli/resources/tools.py

@@ -0,0 +1,106 @@
+"""`nexla tools` — list / get / set-runtime-config / clear-runtime-config / delete.
+
+Mirrors ``routers/nexla_agent_api/tools.py``.
+"""
+
+from __future__ import annotations
+
+import json as jsonlib
+
+import typer
+
+from .. import client, dryrun, output, validate
+
+app = typer.Typer(name="tools", help="Manage Nexla tools.", no_args_is_help=True)
+
+_COLUMNS = ["id", "name", "kind", "status", "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, page: int = typer.Option(1), per_page: int = typer.Option(50)
+) -> None:
+    """List tools."""
+    if output.ctx_page_all(ctx):
+        for item in client.paginate("/nexla/tools", per_page=per_page):
+            output.emit(item, mode="ndjson", fields=output.ctx_fields(ctx))
+        return
+    params = {"page": page, "per_page": per_page}
+    output.emit(
+        client.request("GET", "/nexla/tools", params=params),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+        columns=_COLUMNS,
+    )
+
+
+@app.command("get")
+def get(ctx: typer.Context, tool_id: int) -> None:
+    """Get one tool by id."""
+    output.emit(
+        client.request("GET", f"/nexla/tools/{tool_id}"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("set-runtime-config")
+def set_runtime_config(
+    ctx: typer.Context,
+    tool_id: int,
+    strategy: str = typer.Option(..., help="'auto' or 'mapped'"),
+    connector_name: str = typer.Option(...),
+    connector_type: str = typer.Option(...),
+    credential_mappings: str | None = typer.Option(
+        None, help="JSON array of {user_id, credential_id}; required when strategy=mapped"
+    ),
+    json_body: str | None = _JSON_OPT,
+    params: list[str] = _PARAMS_OPT,
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Set a tool's credential strategy."""
+    named: dict[str, object] = {
+        "strategy": strategy,
+        "connector_name": connector_name,
+        "connector_type": connector_type,
+        "credential_mappings": jsonlib.loads(credential_mappings) if credential_mappings else None,
+    }
+    body = validate.build_body(named, json_body, params)
+    if dry_run:
+        dryrun.run_dry_run(resource="tools", verb="set-runtime-config", body=body)
+    output.emit(
+        client.request("PATCH", f"/nexla/tools/{tool_id}/runtime-config", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("clear-runtime-config")
+def clear_runtime_config(ctx: typer.Context, tool_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Clear a tool's runtime config."""
+    if dry_run:
+        dryrun.run_dry_run(resource="tools", verb="clear-runtime-config", body={})
+    output.emit(
+        client.request("DELETE", f"/nexla/tools/{tool_id}/runtime-config"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("delete")
+def delete(tool_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Delete a tool."""
+    if dry_run:
+        dryrun.run_dry_run(resource="tools", verb="delete", body={})
+    client.request("DELETE", f"/nexla/tools/{tool_id}")
+    typer.echo(f"deleted tool {tool_id}")

nexla_cli/resources/toolsets.py

@@ -0,0 +1,134 @@
+"""`nexla toolsets` — list / get / create / update / delete / add-nexsets.
+
+Mirrors ``routers/nexla_agent_api/toolsets.py``.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .. import client, dryrun, output, validate
+
+app = typer.Typer(name="toolsets", help="Manage Nexla toolsets.", no_args_is_help=True)
+
+_COLUMNS = ["id", "name", "status", "mcp_gateway_enabled", "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, page: int = typer.Option(1), per_page: int = typer.Option(50)
+) -> None:
+    """List toolsets."""
+    if output.ctx_page_all(ctx):
+        for item in client.paginate("/nexla/toolsets", per_page=per_page):
+            output.emit(item, mode="ndjson", fields=output.ctx_fields(ctx))
+        return
+    params = {"page": page, "per_page": per_page}
+    output.emit(
+        client.request("GET", "/nexla/toolsets", params=params),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+        columns=_COLUMNS,
+    )
+
+
+@app.command("get")
+def get(ctx: typer.Context, toolset_id: int) -> None:
+    """Get one toolset by id."""
+    output.emit(
+        client.request("GET", f"/nexla/toolsets/{toolset_id}"),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("create")
+def create(
+    ctx: typer.Context,
+    name: str = typer.Option(...),
+    nexset_id: list[int] = typer.Option(..., help="Repeatable; at least one nexset id"),
+    description: str | None = typer.Option(None),
+    mcp_gateway_enabled: bool = typer.Option(False),
+    json_body: str | None = _JSON_OPT,
+    params: list[str] = _PARAMS_OPT,
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Create a toolset."""
+    named: dict[str, object] = {
+        "name": name,
+        "description": description,
+        "nexset_ids": list(nexset_id),
+        "mcp_gateway_enabled": mcp_gateway_enabled,
+    }
+    body = validate.build_body(named, json_body, params)
+    if dry_run:
+        dryrun.run_dry_run(resource="toolsets", verb="create", body=body)
+    output.emit(
+        client.request("POST", "/nexla/toolsets", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("update")
+def update(
+    ctx: typer.Context,
+    toolset_id: int,
+    name: str | None = typer.Option(None),
+    description: str | None = typer.Option(None),
+    mcp_gateway_enabled: bool | None = typer.Option(None),
+    json_body: str | None = _JSON_OPT,
+    params: list[str] = _PARAMS_OPT,
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Update a toolset."""
+    named: dict[str, object] = {
+        "name": name,
+        "description": description,
+        "mcp_gateway_enabled": mcp_gateway_enabled,
+    }
+    body = validate.build_body(named, json_body, params)
+    if dry_run:
+        dryrun.run_dry_run(resource="toolsets", verb="update", body=body)
+    output.emit(
+        client.request("PATCH", f"/nexla/toolsets/{toolset_id}", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )
+
+
+@app.command("delete")
+def delete(toolset_id: int, dry_run: bool = _DRY_RUN_OPT) -> None:
+    """Delete a toolset."""
+    if dry_run:
+        dryrun.run_dry_run(resource="toolsets", verb="delete", body={})
+    client.request("DELETE", f"/nexla/toolsets/{toolset_id}")
+    typer.echo(f"deleted toolset {toolset_id}")
+
+
+@app.command("add-nexsets")
+def add_nexsets(
+    ctx: typer.Context,
+    toolset_id: int,
+    nexset_id: list[int] = typer.Option(..., help="Repeatable; at least one nexset id"),
+    dry_run: bool = _DRY_RUN_OPT,
+) -> None:
+    """Add nexsets to an existing toolset."""
+    body = {"nexset_ids": list(nexset_id)}
+    if dry_run:
+        dryrun.run_dry_run(resource="toolsets", verb="add-nexsets", body=body)
+    output.emit(
+        client.request("POST", f"/nexla/toolsets/{toolset_id}/nexsets", json=body),
+        mode=output.ctx_mode(ctx),
+        fields=output.ctx_fields(ctx),
+    )