qvasa-mcp 0.1.0__tar.gz

qvasa_mcp-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+.env
+dist/
+build/
+.pytest_cache/
+.mypy_cache/
+*.mcpb

qvasa_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: qvasa-mcp
+Version: 0.1.0
+Summary: MCP server that exposes the Qvasa user-access agentic API to Claude.
+Author: Qvasa
+License: Proprietary
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp>=1.2.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# qvasa-mcp
+
+MCP server that exposes the Qvasa user-access agentic API to Claude.
+
+This is a thin proxy: Claude sends MCP tool calls over stdio, the server translates each call into one or more HTTP requests against the Qvasa Rails app, and returns the result. It owns session lifecycle (login, refresh on 401 SessionStale, two-token auth) so Claude doesn't have to.
+
+Rails counterpart: `one_qvasa_app` repo, namespace `/user_access/api/*`. The toolkit version constant lives at `app/services/user_access/api/toolkit_version.rb`.
+
+## Configuration
+
+Set these env vars (Claude Desktop injects them from the `.mcpb` config block on install):
+
+| var | required | default | purpose |
+| --- | --- | --- | --- |
+| `QVASA_API_KEY` | yes | — | A user-access token (UAT). Generate at `/user_settings/user_access_tokens` in the Qvasa UI. Format `qva_uat_…`. |
+| `QVASA_API_BASE_URL` | no | `https://qvasa.com` | Override for staging or local dev (e.g. `http://localhost:3000`). |
+
+## Local dev
+
+```sh
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e '.[dev]'
+
+export QVASA_API_KEY=qva_uat_…
+export QVASA_API_BASE_URL=http://localhost:3000
+
+# Run the server (it will read MCP requests on stdin, write responses on stdout).
+qvasa-mcp
+
+# Run the tests.
+pytest
+```
+
+## Tool list (17 total)
+
+**Orientation**
+- `qvasa_overview` — call this FIRST. Returns positioning, intent triggers, intent-keyed workflows, a feedback guide, and the cached session manifest. One call per session; no HTTP round-trip after the first.
+- `qvasa_submit_feedback` — frictionless channel for filing bug reports, feature requests, friction points, unexpected_behavior notes, and impossibility reports back to Qvasa engineering.
+- `qvasa_search_saved_widgets` — search the user's personal-dashboard saved queries (the agent's memory layer). Call BEFORE rebuilding a metric from scratch.
+
+**Discovery — widgets** (unified: search by phrase, browse a group, or list all groups)
+- `qvasa_search_widgets` — pass `query` to search (strict → fuzzy fallback), `group_name` to browse a group, or neither for the groups manifest.
+- `qvasa_describe_widget` — bulk schema fetch (widget_type, component_configurations, inspect block).
+
+**Discovery — filters** (unified: same shape as widgets)
+- `qvasa_search_filters` — pass `query` to search (strict → fuzzy fallback), `group_name` to browse a group, or neither for the groups manifest.
+- `qvasa_describe_filter` — bulk schema fetch.
+
+**Filter values & date range**
+- `qvasa_search_filter_values` — value/parent-record search across 19 filter kinds.
+- `qvasa_search_values_across_attributes` — reverse-lookup a value across static attributes.
+- `qvasa_resolve_date_range` — unified date-range tool. Pass `phrase` for natural-language resolution (e.g. 'yesterday', 'last 7 days') or `strategy` for explicit construction.
+- `qvasa_search_component_configuration_values` — value lookup for widget component_configuration_* fields (9 endpoints).
+
+**Metric execution**
+- `qvasa_query_metric` — kickoff + block-until-done across all 5 chart types (quick_stat, basic_chart, donut_chart, multi_data_chart, heat_map)
+- `qvasa_inspect_metric` — same pattern but materialises a TicketSet (quick_stat / basic_chart / donut_chart only)
+- `qvasa_list_in_flight` — show queued/processing metric requests
+- `qvasa_cancel_metric` — cancel an enqueued request
+
+**Ticket sets** (drill-down on inspect results)
+- `qvasa_describe_ticket_set` — show set metadata + tools_available
+- `qvasa_get_ticket_set_summaries` — paginated AI ticket summaries

qvasa_mcp-0.1.0/README.md

@@ -0,0 +1,64 @@
+# qvasa-mcp
+
+MCP server that exposes the Qvasa user-access agentic API to Claude.
+
+This is a thin proxy: Claude sends MCP tool calls over stdio, the server translates each call into one or more HTTP requests against the Qvasa Rails app, and returns the result. It owns session lifecycle (login, refresh on 401 SessionStale, two-token auth) so Claude doesn't have to.
+
+Rails counterpart: `one_qvasa_app` repo, namespace `/user_access/api/*`. The toolkit version constant lives at `app/services/user_access/api/toolkit_version.rb`.
+
+## Configuration
+
+Set these env vars (Claude Desktop injects them from the `.mcpb` config block on install):
+
+| var | required | default | purpose |
+| --- | --- | --- | --- |
+| `QVASA_API_KEY` | yes | — | A user-access token (UAT). Generate at `/user_settings/user_access_tokens` in the Qvasa UI. Format `qva_uat_…`. |
+| `QVASA_API_BASE_URL` | no | `https://qvasa.com` | Override for staging or local dev (e.g. `http://localhost:3000`). |
+
+## Local dev
+
+```sh
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e '.[dev]'
+
+export QVASA_API_KEY=qva_uat_…
+export QVASA_API_BASE_URL=http://localhost:3000
+
+# Run the server (it will read MCP requests on stdin, write responses on stdout).
+qvasa-mcp
+
+# Run the tests.
+pytest
+```
+
+## Tool list (17 total)
+
+**Orientation**
+- `qvasa_overview` — call this FIRST. Returns positioning, intent triggers, intent-keyed workflows, a feedback guide, and the cached session manifest. One call per session; no HTTP round-trip after the first.
+- `qvasa_submit_feedback` — frictionless channel for filing bug reports, feature requests, friction points, unexpected_behavior notes, and impossibility reports back to Qvasa engineering.
+- `qvasa_search_saved_widgets` — search the user's personal-dashboard saved queries (the agent's memory layer). Call BEFORE rebuilding a metric from scratch.
+
+**Discovery — widgets** (unified: search by phrase, browse a group, or list all groups)
+- `qvasa_search_widgets` — pass `query` to search (strict → fuzzy fallback), `group_name` to browse a group, or neither for the groups manifest.
+- `qvasa_describe_widget` — bulk schema fetch (widget_type, component_configurations, inspect block).
+
+**Discovery — filters** (unified: same shape as widgets)
+- `qvasa_search_filters` — pass `query` to search (strict → fuzzy fallback), `group_name` to browse a group, or neither for the groups manifest.
+- `qvasa_describe_filter` — bulk schema fetch.
+
+**Filter values & date range**
+- `qvasa_search_filter_values` — value/parent-record search across 19 filter kinds.
+- `qvasa_search_values_across_attributes` — reverse-lookup a value across static attributes.
+- `qvasa_resolve_date_range` — unified date-range tool. Pass `phrase` for natural-language resolution (e.g. 'yesterday', 'last 7 days') or `strategy` for explicit construction.
+- `qvasa_search_component_configuration_values` — value lookup for widget component_configuration_* fields (9 endpoints).
+
+**Metric execution**
+- `qvasa_query_metric` — kickoff + block-until-done across all 5 chart types (quick_stat, basic_chart, donut_chart, multi_data_chart, heat_map)
+- `qvasa_inspect_metric` — same pattern but materialises a TicketSet (quick_stat / basic_chart / donut_chart only)
+- `qvasa_list_in_flight` — show queued/processing metric requests
+- `qvasa_cancel_metric` — cancel an enqueued request
+
+**Ticket sets** (drill-down on inspect results)
+- `qvasa_describe_ticket_set` — show set metadata + tools_available
+- `qvasa_get_ticket_set_summaries` — paginated AI ticket summaries

qvasa_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "qvasa-mcp"
+version = "0.1.0"
+description = "MCP server that exposes the Qvasa user-access agentic API to Claude."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Proprietary" }
+authors = [{ name = "Qvasa" }]
+dependencies = [
+    "mcp>=1.2.0",
+    "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "respx>=0.21",
+]
+
+[project.scripts]
+qvasa-mcp = "qvasa_mcp.server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/qvasa_mcp"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

qvasa_mcp-0.1.0/src/qvasa_mcp/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

qvasa_mcp-0.1.0/src/qvasa_mcp/client.py

@@ -0,0 +1,175 @@
+"""HTTP client + session lifecycle for the Qvasa user-access agentic API.
+
+Owns the two-token auth dance so Claude-facing tools don't have to:
+
+  - UAT (long-lived, from QVASA_API_KEY env var) goes in `Authorization: Bearer …`.
+  - Session token (short-lived, 24h TTL) goes in `X-User-Access-Session`.
+  - Session is created lazily on first call and cached in process memory along
+    with the toolkit manifest and version string.
+  - On 401 the client re-creates the session and retries the call once. This
+    covers both natural 24h expiry and `ToolkitVersion::CURRENT` bumps on the
+    Rails side (which surface as `error_code: "session_stale"`).
+
+Anything that needs to hit the API goes through `QvasaClient.request`.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from dataclasses import dataclass, field
+from typing import Any
+
+import httpx
+
+DEFAULT_BASE_URL = "https://qvasa.com"
+SESSIONS_PATH = "/user_access/api/sessions"
+
+
+class QvasaApiError(Exception):
+    """Raised when the API returns a non-2xx response we can't recover from."""
+
+    def __init__(self, status_code: int, body: Any, *, method: str, path: str):
+        self.status_code = status_code
+        self.body = body
+        self.method = method
+        self.path = path
+        super().__init__(f"{method} {path} → {status_code}: {body!r}")
+
+
+class MissingApiKeyError(Exception):
+    """Raised at startup if QVASA_API_KEY is unset."""
+
+
+@dataclass
+class SessionState:
+    session_id: int
+    session_token: str
+    toolkit_version: str
+    manifest: dict[str, Any]
+
+
+@dataclass
+class QvasaClient:
+    api_key: str
+    base_url: str = DEFAULT_BASE_URL
+    timeout_seconds: float = 30.0
+
+    _http: httpx.AsyncClient | None = field(default=None, init=False, repr=False)
+    _session: SessionState | None = field(default=None, init=False, repr=False)
+    _session_lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False, repr=False)
+
+    @classmethod
+    def from_env(cls) -> "QvasaClient":
+        api_key = os.environ.get("QVASA_API_KEY", "").strip()
+        if not api_key:
+            raise MissingApiKeyError(
+                "QVASA_API_KEY env var is required. Generate a token at "
+                "/user_settings/user_access_tokens in the Qvasa UI."
+            )
+        base_url = os.environ.get("QVASA_API_BASE_URL", DEFAULT_BASE_URL).rstrip("/")
+        return cls(api_key=api_key, base_url=base_url)
+
+    async def aclose(self) -> None:
+        if self._http is not None:
+            await self._http.aclose()
+            self._http = None
+
+    async def session(self) -> SessionState:
+        """Return the cached session, creating one if needed."""
+        if self._session is not None:
+            return self._session
+        async with self._session_lock:
+            if self._session is None:
+                self._session = await self._create_session()
+            return self._session
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Any | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> Any:
+        """Make an authenticated request, refreshing the session once on 401."""
+        response = await self._send(method, path, json=json, params=params)
+        if response.status_code == 401 and self._is_session_recoverable_401(response):
+            async with self._session_lock:
+                self._session = await self._create_session()
+            response = await self._send(method, path, json=json, params=params)
+        if response.status_code >= 400:
+            raise QvasaApiError(
+                response.status_code,
+                _safe_json(response),
+                method=method,
+                path=path,
+            )
+        return _safe_json(response)
+
+    async def _send(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Any | None,
+        params: dict[str, Any] | None,
+    ) -> httpx.Response:
+        session = await self.session()
+        return await self._client().request(
+            method,
+            path,
+            json=json,
+            params=params,
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "X-User-Access-Session": session.session_token,
+                "Accept": "application/json",
+            },
+        )
+
+    async def _create_session(self) -> SessionState:
+        """POST /sessions with UAT only — bootstrap path, no session token yet."""
+        response = await self._client().post(
+            SESSIONS_PATH,
+            json={},
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Accept": "application/json",
+            },
+        )
+        if response.status_code >= 400:
+            raise QvasaApiError(
+                response.status_code,
+                _safe_json(response),
+                method="POST",
+                path=SESSIONS_PATH,
+            )
+        body = response.json()
+        return SessionState(
+            session_id=body["session_id"],
+            session_token=body["session_token"],
+            toolkit_version=body["toolkit_version"],
+            manifest=body["toolkit"],
+        )
+
+    def _client(self) -> httpx.AsyncClient:
+        if self._http is None:
+            self._http = httpx.AsyncClient(base_url=self.base_url, timeout=self.timeout_seconds)
+        return self._http
+
+    @staticmethod
+    def _is_session_recoverable_401(response: httpx.Response) -> bool:
+        body = _safe_json(response)
+        if not isinstance(body, dict):
+            # Opaque 401 — treat as recoverable, the worst case is one wasted refresh.
+            return True
+        # Don't retry on missing-UAT 401 — refreshing the session won't help.
+        return body.get("error_code") != "missing_user_access_token"
+
+
+def _safe_json(response: httpx.Response) -> Any:
+    try:
+        return response.json()
+    except ValueError:
+        return response.text

qvasa_mcp-0.1.0/src/qvasa_mcp/server.py

@@ -0,0 +1,257 @@
+"""FastMCP server entry point — registers 17 tools, runs over stdio.
+
+Tools are registered against a shared QvasaClient that owns session lifecycle.
+The `build_server` factory takes the client as an argument so tests can
+substitute a mock; `main()` is the production entry point that reads
+configuration from the environment.
+
+Each tool wrapper runs the inner coroutine through `as_recoverable_result`
+so that Rails-side AgentError envelopes (which carry next_step / fallback_step
+hints designed for agent recovery) are surfaced as normal dict results
+instead of opaque MCP error strings.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from qvasa_mcp import tool_descriptions
+from qvasa_mcp.client import MissingApiKeyError, QvasaClient
+from qvasa_mcp.tools import (
+    builders,
+    component_configurations,
+    feedback,
+    filter_values,
+    filters,
+    metrics,
+    saved_widgets,
+    session,
+    ticket_sets,
+    widgets,
+)
+from qvasa_mcp.tools._helpers import as_recoverable_result
+
+
+def build_server(client: QvasaClient) -> FastMCP:
+    mcp = FastMCP("qvasa")
+
+    # Orientation — the elegant front door. Registered first so MCP hosts that
+    # surface tools in registration order put it at the top of the list. ----
+
+    @mcp.tool(description=tool_descriptions.QVASA_OVERVIEW)
+    async def qvasa_overview() -> dict[str, Any]:
+        return await session.get_overview(client)
+
+    @mcp.tool(description=tool_descriptions.SUBMIT_FEEDBACK)
+    async def qvasa_submit_feedback(
+        feedback_type: str,
+        content: str,
+        context: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        if feedback_type not in feedback.FEEDBACK_TYPES:
+            raise ValueError(
+                f"feedback_type must be one of {feedback.FEEDBACK_TYPES}, "
+                f"got {feedback_type!r}"
+            )
+        return await as_recoverable_result(
+            feedback.submit_feedback(
+                client,
+                feedback_type=feedback_type,  # type: ignore[arg-type]
+                content=content,
+                context=context,
+            )
+        )
+
+    # Memory layer: personal-dashboard saved-widget search ----------------
+
+    @mcp.tool(description=tool_descriptions.SEARCH_SAVED_WIDGETS)
+    async def qvasa_search_saved_widgets(query: str) -> dict[str, Any]:
+        return await as_recoverable_result(saved_widgets.search_saved_widgets(client, query))
+
+    # Discovery: widgets (unified search / browse-by-group / list-all) -----
+
+    @mcp.tool(description=tool_descriptions.SEARCH_WIDGETS)
+    async def qvasa_search_widgets(
+        query: str | None = None,
+        group_name: str | None = None,
+    ) -> dict[str, Any]:
+        return await as_recoverable_result(
+            widgets.search_widgets(client, query=query, group_name=group_name)
+        )
+
+    @mcp.tool(description=tool_descriptions.DESCRIBE_WIDGET)
+    async def qvasa_describe_widget(widget_names: list[str]) -> dict[str, Any]:
+        return await as_recoverable_result(widgets.describe_widget(client, widget_names))
+
+    # Discovery: filters (unified search / browse-by-group / list-all) -----
+
+    @mcp.tool(description=tool_descriptions.SEARCH_FILTERS)
+    async def qvasa_search_filters(
+        query: str | None = None,
+        group_name: str | None = None,
+    ) -> dict[str, Any]:
+        return await as_recoverable_result(
+            filters.search_filters(client, query=query, group_name=group_name)
+        )
+
+    @mcp.tool(description=tool_descriptions.DESCRIBE_FILTER)
+    async def qvasa_describe_filter(kind_keys: list[str]) -> dict[str, Any]:
+        return await as_recoverable_result(filters.describe_filter(client, kind_keys))
+
+    # Filter values ---------------------------------------------------------
+
+    @mcp.tool(description=tool_descriptions.SEARCH_FILTER_VALUES)
+    async def qvasa_search_filter_values(
+        kind_key: str,
+        query: str,
+        parent_id: int | str | None = None,
+    ) -> dict[str, Any]:
+        return await as_recoverable_result(
+            filter_values.search_filter_values(
+                client, kind_key=kind_key, query=query, parent_id=parent_id
+            )
+        )
+
+    @mcp.tool(description=tool_descriptions.SEARCH_VALUES_ACROSS_ATTRIBUTES)
+    async def qvasa_search_values_across_attributes(value: str) -> dict[str, Any]:
+        return await as_recoverable_result(
+            filter_values.search_values_across_attributes(client, value)
+        )
+
+    # Date range (unified discover + build) ---------------------------------
+
+    @mcp.tool(description=tool_descriptions.RESOLVE_DATE_RANGE)
+    async def qvasa_resolve_date_range(
+        phrase: str | None = None,
+        strategy: str | None = None,
+        time_unit: str | None = None,
+        time_length: int | None = None,
+        start_at: str | None = None,
+        end_at: str | None = None,
+    ) -> dict[str, Any]:
+        return await as_recoverable_result(
+            builders.resolve_date_range(
+                client,
+                phrase=phrase,
+                strategy=strategy,
+                time_unit=time_unit,
+                time_length=time_length,
+                start_at=start_at,
+                end_at=end_at,
+            )
+        )
+
+    # Component configuration values ---------------------------------------
+
+    @mcp.tool(description=tool_descriptions.SEARCH_COMPONENT_CONFIGURATION_VALUES)
+    async def qvasa_search_component_configuration_values(
+        configuration_kind: str,
+        query: str,
+        parent_id: int | str | None = None,
+    ) -> dict[str, Any]:
+        return await as_recoverable_result(
+            component_configurations.search_component_configuration_values(
+                client,
+                configuration_kind=configuration_kind,
+                query=query,
+                parent_id=parent_id,
+            )
+        )
+
+    # Metrics ---------------------------------------------------------------
+
+    @mcp.tool(description=tool_descriptions.QUERY_METRIC)
+    async def qvasa_query_metric(
+        metric_kind: str,
+        metric_name: str,
+        filters_json: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        if metric_kind not in metrics.METRIC_KIND_TO_KICKOFF_PATH:
+            raise ValueError(
+                f"metric_kind must be one of "
+                f"{sorted(metrics.METRIC_KIND_TO_KICKOFF_PATH)}, got {metric_kind!r}"
+            )
+        return await as_recoverable_result(
+            metrics.query_metric(
+                client,
+                metric_kind=metric_kind,  # type: ignore[arg-type]
+                metric_name=metric_name,
+                filters_json=filters_json,
+            )
+        )
+
+    @mcp.tool(description=tool_descriptions.INSPECT_METRIC)
+    async def qvasa_inspect_metric(
+        metric_kind: str,
+        metric_name: str,
+        filters_json: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        if metric_kind not in metrics.INSPECT_KIND_TO_KICKOFF_PATH:
+            raise ValueError(
+                f"metric_kind must be one of "
+                f"{sorted(metrics.INSPECT_KIND_TO_KICKOFF_PATH)} for inspect "
+                f"(heat_map and multi_data_chart are not inspectable), "
+                f"got {metric_kind!r}"
+            )
+        return await as_recoverable_result(
+            metrics.inspect_metric(
+                client,
+                metric_kind=metric_kind,  # type: ignore[arg-type]
+                metric_name=metric_name,
+                filters_json=filters_json,
+            )
+        )
+
+    @mcp.tool(description=tool_descriptions.LIST_IN_FLIGHT)
+    async def qvasa_list_in_flight() -> dict[str, Any]:
+        return await as_recoverable_result(metrics.list_in_flight(client))
+
+    @mcp.tool(description=tool_descriptions.CANCEL_METRIC)
+    async def qvasa_cancel_metric(uuid: str) -> dict[str, Any]:
+        return await as_recoverable_result(metrics.cancel_metric(client, uuid))
+
+    # Ticket sets -----------------------------------------------------------
+
+    @mcp.tool(description=tool_descriptions.DESCRIBE_TICKET_SET)
+    async def qvasa_describe_ticket_set(ticket_set_id: int) -> dict[str, Any]:
+        return await as_recoverable_result(ticket_sets.describe_ticket_set(client, ticket_set_id))
+
+    @mcp.tool(description=tool_descriptions.GET_TICKET_SET_SUMMARIES)
+    async def qvasa_get_ticket_set_summaries(
+        ticket_set_id: int,
+        summary_kind: str = "short",
+        max_results: int = ticket_sets.DEFAULT_MAX_SUMMARIES,
+        after_id: int | None = None,
+    ) -> dict[str, Any]:
+        if summary_kind not in ("short", "long"):
+            raise ValueError(
+                f"summary_kind must be 'short' or 'long', got {summary_kind!r}"
+            )
+        return await as_recoverable_result(
+            ticket_sets.get_ticket_set_summaries(
+                client,
+                ticket_set_id=ticket_set_id,
+                summary_kind=summary_kind,  # type: ignore[arg-type]
+                max_results=max_results,
+                after_id=after_id,
+            )
+        )
+
+    return mcp
+
+
+def main() -> None:
+    try:
+        client = QvasaClient.from_env()
+    except MissingApiKeyError as exc:
+        print(f"qvasa-mcp: {exc}", file=sys.stderr)
+        sys.exit(1)
+    server = build_server(client)
+    server.run()
+
+
+if __name__ == "__main__":
+    main()