general-augment-cli 0.1.0__py3-none-any.whl

platform_cli/commands/integrate.py

@@ -0,0 +1,94 @@
+"""OpenAPI integration scaffolding command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from platform_cli.client import encode_path_segment
+from platform_cli.openapi import scaffold_from_openapi
+from platform_cli.output import print_success, print_warning, table
+from platform_cli.runtime import Runtime
+
+
+def integrate(
+    ctx: typer.Context,
+    spec_url: Annotated[str, typer.Argument(help="OpenAPI spec URL or file path.")],
+    name: Annotated[str | None, typer.Option(help="Agent name.")] = None,
+    output_dir: Annotated[Path | None, typer.Option(help="Output directory.")] = None,
+    description: Annotated[
+        str | None,
+        typer.Option(help="Agent personality description."),
+    ] = None,
+    target_count: Annotated[int, typer.Option(help="Target generated tool count.")] = 15,
+    force: Annotated[bool, typer.Option(help="Overwrite existing generated files.")] = False,
+    auto_deploy: Annotated[
+        bool,
+        typer.Option(help="Deploy immediately after scaffolding."),
+    ] = False,
+) -> None:
+    """Generate a local agent scaffold from an OpenAPI spec."""
+    runtime: Runtime = ctx.obj
+    result = scaffold_from_openapi(
+        spec_url,
+        output_dir=output_dir,
+        name=name,
+        description=description,
+        target_count=target_count,
+        force=force,
+    )
+    rows: list[list[object]] = [
+        [
+            "disabled" if not tool.enabled else "enabled",
+            tool.tool_id,
+            tool.http_method,
+            tool.risk_level,
+            "yes" if tool.requires_approval else "no",
+        ]
+        for tool in result.tools
+    ]
+    table(
+        f"Generated {len(result.tools)} tools from {len(result.parsed_api.tools)} endpoints",
+        ["State", "Tool", "Method", "Risk", "Approval"],
+        rows,
+    )
+    print_success(f"Generated scaffold in {result.root}")
+    print_success(f"Coding-agent handoff written to {result.agent_prompt_path}")
+    if any(not tool.enabled for tool in result.tools):
+        print_warning("Destructive operations are disabled by default.")
+    if auto_deploy:
+        from platform_cli.commands.deploy import deploy_path
+
+        project = deploy_path(runtime, result.config_path, project_ref=None)
+        project_id = project.get("id")
+        if not project_id:
+            print_warning(
+                "Project deployed, but OpenAPI tools were not registered: missing project id."
+            )
+            return
+        with runtime.client() as client:
+            response = client.admin(
+                "POST",
+                f"/projects/{encode_path_segment(str(project_id))}/tools/from-openapi",
+                json={
+                    "spec_url": _deployable_spec_source(spec_url),
+                    "target_count": target_count,
+                    "auto_deploy": True,
+                },
+            )
+        generated = response.get("generated_count", 0)
+        curated = response.get("curated_count", 0)
+        enabled = len(response.get("enabled_tool_ids") or [])
+        print_success(
+            f"Registered OpenAPI tools: {enabled} enabled, {curated} curated, {generated} generated"
+        )
+
+
+def _deployable_spec_source(spec_url: str) -> str:
+    """Return a server-readable OpenAPI source for hosted registration."""
+    spec_path = Path(spec_url).expanduser()
+    if spec_path.exists() and spec_path.is_file():
+        return spec_path.read_text(encoding="utf-8")
+    return spec_url

platform_cli/commands/keys.py

@@ -0,0 +1,116 @@
+"""API key management commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from platform_cli.client import encode_path_segment, resolve_project
+from platform_cli.output import panel, print_success, print_warning, table
+from platform_cli.runtime import Runtime
+
+app = typer.Typer(help="Manage project-scoped API keys.")
+
+
+@app.command("list")
+def list_keys(ctx: typer.Context) -> None:
+    """List masked API keys visible to this management credential."""
+
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        payload = client.admin("GET", "/keys")
+    items = payload.get("items", []) if isinstance(payload, dict) else []
+    rows = [
+        [
+            item.get("name", ""),
+            item.get("masked_key", ""),
+            item.get("project_id", ""),
+            ",".join(item.get("scopes", [])),
+            item.get("expires_at", "") or "",
+            item.get("id", ""),
+        ]
+        for item in items
+        if isinstance(item, dict)
+    ]
+    table("API Keys", ["Name", "Key", "Project", "Scopes", "Expires", "ID"], rows)
+
+
+@app.command("create")
+def create_key(
+    ctx: typer.Context,
+    name: str = typer.Option(..., help="Display name, for example Production backend."),
+    project: str | None = typer.Option(None, help="Project id, slug, or name."),
+    scope: Annotated[
+        list[str] | None,
+        typer.Option("--scope", help="Scope to grant; repeatable."),
+    ] = None,
+    expires_at: str | None = typer.Option(None, help="Optional ISO-8601 expiration timestamp."),
+) -> None:
+    """Create an API key and print the raw secret once."""
+
+    runtime: Runtime = ctx.obj
+    payload: dict[str, object] = {
+        "name": name,
+        "scopes": scope or ["admin"],
+    }
+    with runtime.client() as client:
+        if project:
+            project_payload = resolve_project(client, project)
+            payload["project_id"] = str(project_payload["id"])
+        if expires_at is not None:
+            payload["expires_at"] = expires_at
+        response = client.admin("POST", "/keys", json=payload)
+    print_success(
+        f"Created API key {response.get('name', name)} ({response.get('id', 'unknown')})."
+    )
+    print_warning("The raw API key is shown once. Store it in your backend secret manager.")
+    panel(
+        "API Key",
+        f"api_key: {response.get('api_key', '')}\n"
+        f"masked_key: {response.get('masked_key', '')}\n"
+        f"project_id: {response.get('project_id', payload.get('project_id', ''))}\n"
+        f"scopes: {','.join(response.get('scopes', []))}",
+    )
+
+
+@app.command("update")
+def update_key(
+    ctx: typer.Context,
+    key_id: str = typer.Argument(..., help="API key id."),
+    name: str | None = typer.Option(None, help="New display name."),
+    scope: Annotated[
+        list[str] | None,
+        typer.Option("--scope", help="Replacement scope; repeatable."),
+    ] = None,
+    expires_at: str | None = typer.Option(None, help="Replacement ISO-8601 expiration timestamp."),
+    clear_expiration: bool = typer.Option(False, help="Clear the key expiration."),
+) -> None:
+    """Update API key metadata without showing the raw secret."""
+
+    runtime: Runtime = ctx.obj
+    payload: dict[str, object | None] = {}
+    if name is not None:
+        payload["name"] = name
+    if scope is not None:
+        payload["scopes"] = scope
+    if clear_expiration:
+        payload["expires_at"] = None
+    elif expires_at is not None:
+        payload["expires_at"] = expires_at
+    with runtime.client() as client:
+        response = client.admin("PATCH", f"/keys/{encode_path_segment(key_id)}", json=payload)
+    print_success(f"Updated API key {response.get('name', key_id)}.")
+
+
+@app.command("revoke")
+def revoke_key(
+    ctx: typer.Context,
+    key_id: str = typer.Argument(..., help="API key id."),
+) -> None:
+    """Revoke an API key."""
+
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        response = client.admin("DELETE", f"/keys/{encode_path_segment(key_id)}")
+    print_success(f"Revoked API key {response.get('id', key_id)}.")

platform_cli/commands/logs.py

@@ -0,0 +1,43 @@
+"""Project log streaming command."""
+
+from __future__ import annotations
+
+import time
+
+import typer
+
+from platform_cli.client import encode_path_segment, resolve_project
+from platform_cli.output import table
+from platform_cli.runtime import Runtime
+
+
+def logs(
+    ctx: typer.Context,
+    project: str = typer.Option(..., help="Project id, slug, or name."),
+    follow: bool = typer.Option(False, "--follow", help="Poll continuously."),
+    limit: int = typer.Option(25, min=1, max=200, help="Log row limit."),
+) -> None:
+    """Show recent project logs."""
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        while True:
+            payload = client.admin(
+                "GET",
+                f"/projects/{encode_path_segment(str(project_payload['id']))}/logs",
+                params={"limit": limit},
+            )
+            items = payload.get("items", []) if isinstance(payload, dict) else []
+            rows = [
+                [
+                    item.get("created_at", ""),
+                    item.get("role", ""),
+                    str(item.get("content", ""))[:80],
+                ]
+                for item in items
+                if isinstance(item, dict)
+            ]
+            table("Logs", ["Time", "Role", "Content"], rows)
+            if not follow:
+                return
+            time.sleep(2)

platform_cli/commands/mcp.py

@@ -0,0 +1,258 @@
+"""MCP server management commands."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import typer
+
+from platform_cli.client import encode_path_segment, resolve_project
+from platform_cli.output import print_json, print_success, table
+from platform_cli.runtime import Runtime
+
+app = typer.Typer(help="Manage tenant MCP servers.")
+
+
+@app.command("list")
+def list_mcp_servers(
+    ctx: typer.Context,
+    project: Annotated[str, typer.Option(help="Project id, slug, or name.")],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print machine-readable JSON."),
+    ] = False,
+) -> None:
+    """List MCP servers configured for one project."""
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        payload = client.admin(
+            "GET",
+            f"/projects/{encode_path_segment(str(project_payload['id']))}/mcp-servers",
+        )
+    if json_output:
+        print_json(payload)
+        return
+    items = payload.get("items", []) if isinstance(payload, dict) else []
+    rows = [_server_row(item) for item in items if isinstance(item, dict)]
+    table("MCP servers", ["Name", "Transport", "Enabled", "Endpoint", "Tools"], rows)
+
+
+@app.command("add")
+def add_mcp_server(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="MCP server name.")],
+    project: Annotated[str, typer.Option(help="Project id, slug, or name.")],
+    url: Annotated[str | None, typer.Option(help="HTTP MCP endpoint URL.")] = None,
+    command: Annotated[str | None, typer.Option(help="Stdio MCP command.")] = None,
+    arg: Annotated[
+        list[str] | None,
+        typer.Option("--arg", help="Stdio command argument. Repeatable."),
+    ] = None,
+    header: Annotated[
+        list[str] | None,
+        typer.Option("--header", help="HTTP header as key=value. Repeatable."),
+    ] = None,
+    env: Annotated[
+        list[str] | None,
+        typer.Option("--env", help="Stdio environment value as key=value. Repeatable."),
+    ] = None,
+    include_tool: Annotated[
+        list[str] | None,
+        typer.Option("--include-tool", help="MCP tool name to expose. Repeatable."),
+    ] = None,
+    exclude_tool: Annotated[
+        list[str] | None,
+        typer.Option("--exclude-tool", help="MCP tool name to hide. Repeatable."),
+    ] = None,
+    timeout: Annotated[int | None, typer.Option(min=1, help="Runtime timeout seconds.")] = None,
+    connect_timeout: Annotated[
+        int | None,
+        typer.Option("--connect-timeout", min=1, help="Connection timeout seconds."),
+    ] = None,
+    enabled: Annotated[
+        bool,
+        typer.Option("--enabled/--disabled", help="Whether Hermes may use this server."),
+    ] = True,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print machine-readable JSON."),
+    ] = False,
+) -> None:
+    """Add one HTTP or stdio MCP server to a project."""
+    if bool(url) == bool(command):
+        raise typer.BadParameter("Provide exactly one transport: --url or --command.")
+    payload: dict[str, Any] = {"name": name, "enabled": enabled}
+    if url:
+        payload["url"] = url
+    if command:
+        payload["command"] = command
+    if arg:
+        payload["args"] = list(arg)
+    headers = _key_value_pairs(header or [], option="--header")
+    if headers:
+        payload["headers"] = headers
+    env_values = _key_value_pairs(env or [], option="--env")
+    if env_values:
+        payload["env"] = env_values
+    tools = _tools_filter(include_tool or [], exclude_tool or [])
+    if tools:
+        payload["tools"] = tools
+    if timeout is not None:
+        payload["timeout"] = timeout
+    if connect_timeout is not None:
+        payload["connect_timeout"] = connect_timeout
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        response = client.admin(
+            "POST",
+            f"/projects/{encode_path_segment(str(project_payload['id']))}/mcp-servers",
+            json=payload,
+        )
+    if json_output:
+        print_json(response)
+        return
+    table(
+        "Added MCP server",
+        ["Field", "Value"],
+        [
+            ["Project", project],
+            ["Name", _value(response, "name") or name],
+            ["Transport", _transport(response if isinstance(response, dict) else payload)],
+            ["Enabled", _value(response, "enabled")],
+            ["Tools", _tools_label(response if isinstance(response, dict) else payload)],
+        ],
+    )
+
+
+@app.command("test")
+def test_mcp_server(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="MCP server name.")],
+    project: Annotated[str, typer.Option(help="Project id, slug, or name.")],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print machine-readable JSON."),
+    ] = False,
+) -> None:
+    """Test one configured MCP server."""
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        response = client.admin(
+            "POST",
+            (
+                f"/projects/{encode_path_segment(str(project_payload['id']))}/mcp-servers/"
+                f"{encode_path_segment(name)}/test"
+            ),
+        )
+    if json_output:
+        print_json(response)
+        return
+    table(
+        "MCP server test",
+        ["Field", "Value"],
+        [
+            ["Name", _value(response, "name")],
+            ["OK", _value(response, "ok")],
+            ["Transport", _value(response, "transport")],
+            ["Detail", _value(response, "detail")],
+        ],
+    )
+
+
+@app.command("delete")
+def delete_mcp_server(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="MCP server name.")],
+    project: Annotated[str, typer.Option(help="Project id, slug, or name.")],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print machine-readable JSON."),
+    ] = False,
+) -> None:
+    """Delete one configured MCP server."""
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        response = client.admin(
+            "DELETE",
+            (
+                f"/projects/{encode_path_segment(str(project_payload['id']))}/mcp-servers/"
+                f"{encode_path_segment(name)}"
+            ),
+        )
+    if json_output:
+        print_json(response)
+        return
+    deleted_name = response.get("name", name) if isinstance(response, dict) else name
+    print_success(f"Deleted MCP server {deleted_name}.")
+
+
+def _key_value_pairs(values: list[str], *, option: str) -> dict[str, str]:
+    """Parse repeated key=value CLI flags."""
+    parsed: dict[str, str] = {}
+    for item in values:
+        key, separator, value = item.partition("=")
+        if not separator or not key.strip():
+            raise typer.BadParameter(f"{option} values must use key=value.")
+        parsed[key.strip()] = value
+    return parsed
+
+
+def _tools_filter(include: list[str], exclude: list[str]) -> dict[str, list[str]]:
+    """Return MCP tool include/exclude filters."""
+    tools: dict[str, list[str]] = {}
+    if include:
+        tools["include"] = include
+    if exclude:
+        tools["exclude"] = exclude
+    return tools
+
+
+def _server_row(server: dict[str, Any]) -> list[object]:
+    """Return a table row for one MCP server."""
+    return [
+        server.get("name", ""),
+        _transport(server),
+        "yes" if server.get("enabled", True) else "no",
+        server.get("url") or server.get("command") or "",
+        _tools_label(server),
+    ]
+
+
+def _transport(server: dict[str, Any]) -> str:
+    """Return MCP transport label."""
+    if server.get("url"):
+        return "http"
+    if server.get("command"):
+        return "stdio"
+    return "unknown"
+
+
+def _tools_label(server: dict[str, Any]) -> str:
+    """Return a compact tool filter label."""
+    tools = server.get("tools")
+    if not isinstance(tools, dict):
+        return "all"
+    include = _string_list(tools.get("include"))
+    exclude = _string_list(tools.get("exclude"))
+    labels: list[str] = []
+    if include:
+        labels.append("include: " + ", ".join(include))
+    if exclude:
+        labels.append("exclude: " + ", ".join(exclude))
+    return "; ".join(labels) if labels else "all"
+
+
+def _string_list(value: object) -> list[str]:
+    """Return a string list from JSON."""
+    return [str(item) for item in value] if isinstance(value, list) else []
+
+
+def _value(payload: object, key: str) -> object:
+    """Safely read a value from a response mapping."""
+    if isinstance(payload, dict):
+        return payload.get(key, "")
+    return ""