@aborruso/ckan-mcp-server 0.4.11 → 0.4.14

package/examples/langgraph/metadata_quality.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""
+Metadata Quality Scoring for CKAN Datasets
+
+Advanced quality scoring system based on:
+- Completeness (required and recommended fields)
+- Richness (descriptions, tags, temporal coverage)
+- Resources quality (formats, accessibility)
+- Temporal freshness
+
+Score: 0-100 points
+"""
+
+from datetime import datetime
+from typing import Any
+
+
+class MetadataQualityScorer:
+    """Calculate metadata quality score for CKAN datasets."""
+
+    # Quality thresholds
+    EXCELLENT = 80
+    GOOD = 60
+    ACCEPTABLE = 40
+    POOR = 0
+
+    @classmethod
+    def score_dataset(cls, dataset: dict[str, Any]) -> dict[str, Any]:
+        """
+        Calculate comprehensive quality score.
+
+        Returns:
+            {
+                "score": 75,              # Total score 0-100
+                "level": "good",          # excellent/good/acceptable/poor
+                "breakdown": {
+                    "completeness": 20,   # out of 30
+                    "richness": 15,       # out of 30
+                    "resources": 25,      # out of 30
+                    "freshness": 8        # out of 10
+                },
+                "issues": ["Missing license", ...]
+            }
+        """
+        issues = []
+        breakdown = {
+            "completeness": cls._score_completeness(dataset, issues),
+            "richness": cls._score_richness(dataset, issues),
+            "resources": cls._score_resources(dataset, issues),
+            "freshness": cls._score_freshness(dataset, issues),
+        }
+
+        total_score = sum(breakdown.values())
+        level = cls._get_level(total_score)
+
+        return {
+            "score": total_score,
+            "level": level,
+            "breakdown": breakdown,
+            "issues": issues,
+        }
+
+    @classmethod
+    def _score_completeness(cls, dataset: dict, issues: list) -> int:
+        """Score 0-30: Required and recommended fields."""
+        score = 0
+
+        # Required fields (15 points)
+        if dataset.get("title"):
+            score += 5
+        else:
+            issues.append("Missing title")
+
+        if dataset.get("notes"):  # Description
+            score += 5
+        else:
+            issues.append("Missing description")
+
+        if dataset.get("name"):  # Identifier
+            score += 5
+        else:
+            issues.append("Missing identifier")
+
+        # Recommended fields (15 points)
+        if dataset.get("license_id"):
+            score += 3
+        else:
+            issues.append("Missing license")
+
+        if dataset.get("author") or dataset.get("maintainer"):
+            score += 3
+        else:
+            issues.append("Missing author/maintainer")
+
+        if dataset.get("author_email") or dataset.get("maintainer_email"):
+            score += 3
+        else:
+            issues.append("Missing contact email")
+
+        # Organization
+        if dataset.get("organization"):
+            score += 3
+        else:
+            issues.append("Not assigned to organization")
+
+        # Geographical coverage
+        if dataset.get("extras"):
+            has_geo = any(
+                e.get("key") in ["spatial", "geographic_coverage"]
+                for e in dataset.get("extras", [])
+            )
+            if has_geo:
+                score += 3
+
+        return score
+
+    @classmethod
+    def _score_richness(cls, dataset: dict, issues: list) -> int:
+        """Score 0-30: Richness of metadata."""
+        score = 0
+
+        # Description quality (10 points)
+        notes = dataset.get("notes", "")
+        if len(notes) > 200:
+            score += 10
+        elif len(notes) > 100:
+            score += 5
+        elif len(notes) > 0:
+            score += 2
+        else:
+            issues.append("Very short or missing description")
+
+        # Tags (10 points)
+        tags = dataset.get("tags", [])
+        num_tags = len(tags)
+        if num_tags >= 5:
+            score += 10
+        elif num_tags >= 3:
+            score += 6
+        elif num_tags >= 1:
+            score += 3
+        else:
+            issues.append("No tags")
+
+        # Temporal coverage (5 points)
+        extras = {e.get("key"): e.get("value") for e in dataset.get("extras", [])}
+        if "temporal_start" in extras or "temporal_end" in extras:
+            score += 3
+
+        # Frequency/update schedule (5 points)
+        if extras.get("frequency") or extras.get("update_frequency"):
+            score += 2
+
+        return score
+
+    @classmethod
+    def _score_resources(cls, dataset: dict, issues: list) -> int:
+        """Score 0-30: Resources quality."""
+        score = 0
+        resources = dataset.get("resources", [])
+
+        if not resources:
+            issues.append("No resources")
+            return 0
+
+        # At least one resource (5 points)
+        score += 5
+
+        # Check formats (10 points)
+        formats = {r.get("format", "").upper() for r in resources}
+        open_formats = {"CSV", "JSON", "GEOJSON", "XML", "RDF", "JSONLD"}
+        if formats & open_formats:
+            score += 10
+            if "CSV" in formats:
+                score += 2  # Bonus for CSV
+        else:
+            issues.append("No open formats (CSV/JSON/XML)")
+
+        # Resource descriptions (5 points)
+        described = sum(1 for r in resources if r.get("description"))
+        if described == len(resources):
+            score += 5
+        elif described > 0:
+            score += 2
+
+        # DataStore availability (5 points)
+        has_datastore = any(r.get("datastore_active") for r in resources)
+        if has_datastore:
+            score += 5
+
+        # URLs validity (5 points)
+        valid_urls = sum(
+            1 for r in resources if r.get("url") and r["url"].startswith("http")
+        )
+        if valid_urls == len(resources):
+            score += 5
+        elif valid_urls > 0:
+            score += 2
+        else:
+            issues.append("Invalid or missing resource URLs")
+
+        return score
+
+    @classmethod
+    def _score_freshness(cls, dataset: dict, issues: list) -> int:
+        """Score 0-10: Temporal freshness."""
+        score = 0
+
+        # Check metadata_modified
+        modified_str = dataset.get("metadata_modified")
+        if not modified_str:
+            issues.append("No last modified date")
+            return 0
+
+        try:
+            modified = datetime.fromisoformat(modified_str.replace("Z", "+00:00"))
+            now = datetime.now(modified.tzinfo)
+            days_old = (now - modified).days
+
+            if days_old < 90:  # < 3 months
+                score = 10
+            elif days_old < 180:  # < 6 months
+                score = 7
+            elif days_old < 365:  # < 1 year
+                score = 5
+            elif days_old < 730:  # < 2 years
+                score = 3
+            else:
+                score = 1
+                issues.append(f"Last updated {days_old} days ago")
+
+        except (ValueError, AttributeError):
+            issues.append("Invalid date format")
+
+        return score
+
+    @classmethod
+    def _get_level(cls, score: int) -> str:
+        """Convert score to quality level."""
+        if score >= cls.EXCELLENT:
+            return "excellent"
+        elif score >= cls.GOOD:
+            return "good"
+        elif score >= cls.ACCEPTABLE:
+            return "acceptable"
+        else:
+            return "poor"
+
+
+# Example usage
+if __name__ == "__main__":
+    # Sample dataset
+    sample_dataset = {
+        "title": "Sample Dataset",
+        "name": "sample-dataset",
+        "notes": "This is a sample dataset with a detailed description " * 5,
+        "license_id": "cc-by-4.0",
+        "author": "Mario Rossi",
+        "author_email": "mario@example.com",
+        "organization": {"name": "comune-roma"},
+        "tags": [
+            {"name": "environment"},
+            {"name": "air-quality"},
+            {"name": "open-data"},
+        ],
+        "resources": [
+            {
+                "format": "CSV",
+                "url": "https://example.com/data.csv",
+                "description": "Data in CSV format",
+                "datastore_active": True,
+            },
+            {
+                "format": "JSON",
+                "url": "https://example.com/data.json",
+                "description": "Data in JSON format",
+            },
+        ],
+        "metadata_modified": "2025-01-15T10:00:00Z",
+    }
+
+    scorer = MetadataQualityScorer()
+    result = scorer.score_dataset(sample_dataset)
+
+    print("Metadata Quality Assessment")
+    print("=" * 50)
+    print(f"Overall Score: {result['score']}/100")
+    print(f"Quality Level: {result['level'].upper()}")
+    print(f"\nBreakdown:")
+    for category, score in result["breakdown"].items():
+        print(
+            f"  {category.capitalize():15} {score:2}/30"
+            if category != "freshness"
+            else f"  {category.capitalize():15} {score:2}/10"
+        )
+    if result["issues"]:
+        print(f"\nIssues ({len(result['issues'])}):")
+        for issue in result["issues"]:
+            print(f"  - {issue}")

package/examples/langgraph/requirements.txt

@@ -0,0 +1,12 @@
+# LangGraph Examples - Python Dependencies
+
+# Core dependencies
+langgraph>=0.2.0
+langchain-core>=0.3.0
+
+# MCP Python SDK for client connection
+mcp>=1.0.0
+
+# Optional: LangSmith for debugging/tracing
+# Uncomment if you want to use LangSmith
+# langsmith>=0.1.0

package/examples/langgraph/setup.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# Setup script for LangGraph examples
+
+set -e
+
+echo "Setting up LangGraph examples environment..."
+
+# Check Python version
+python3 --version
+
+# Create virtual environment if it doesn't exist
+if [ ! -d "venv" ]; then
+	echo "Creating virtual environment..."
+	python3 -m venv venv
+fi
+
+# Activate virtual environment
+source venv/bin/activate
+
+# Install dependencies
+echo "Installing dependencies..."
+pip install -r requirements.txt
+
+echo ""
+echo "✓ Setup complete!"
+echo ""
+echo "To activate the environment:"
+echo "  source venv/bin/activate"
+echo ""
+echo "To run examples:"
+echo "  python 01_basic_workflow.py"
+echo "  python 02_data_exploration.py"

package/examples/langgraph/test_setup.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+Quick test to verify LangGraph + MCP setup
+
+Run:
+    uvx --with langgraph --with mcp --with langchain-core python test_setup.py
+"""
+
+import sys
+
+
+def test_imports():
+    """Test that all required packages are available."""
+    print("Testing imports...")
+    errors = []
+
+    try:
+        import langgraph  # noqa: F401
+
+        print("✓ langgraph")
+    except ImportError as e:
+        errors.append(f"✗ langgraph: {e}")
+
+    try:
+        import mcp  # noqa: F401
+
+        print("✓ mcp")
+    except ImportError as e:
+        errors.append(f"✗ mcp: {e}")
+
+    try:
+        import langchain_core  # noqa: F401
+
+        print("✓ langchain_core")
+    except ImportError as e:
+        errors.append(f"✗ langchain_core: {e}")
+
+    return errors
+
+
+def test_mcp_server():
+    """Test that MCP server file exists."""
+    import os
+
+    print("\nTesting MCP server...")
+    server_path = os.path.join(os.path.dirname(__file__), "../../dist/index.js")
+
+    if os.path.exists(server_path):
+        print(f"✓ MCP server found: {server_path}")
+        return []
+    else:
+        return [
+            f"✗ MCP server not found: {server_path}",
+            "  Run: cd ../.. && npm run build",
+        ]
+
+
+def test_node():
+    """Test that Node.js is available."""
+    import subprocess
+
+    print("\nTesting Node.js...")
+    try:
+        result = subprocess.run(
+            ["node", "--version"], capture_output=True, text=True, check=True
+        )
+        version = result.stdout.strip()
+        print(f"✓ Node.js {version}")
+        return []
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return ["✗ Node.js not found or not in PATH"]
+
+
+def main():
+    """Run all tests."""
+    print("=" * 60)
+    print("LangGraph + CKAN MCP Setup Test")
+    print("=" * 60)
+
+    all_errors = []
+
+    # Run tests
+    all_errors.extend(test_imports())
+    all_errors.extend(test_node())
+    all_errors.extend(test_mcp_server())
+
+    # Summary
+    print("\n" + "=" * 60)
+    if all_errors:
+        print("SETUP INCOMPLETE")
+        print("=" * 60)
+        for error in all_errors:
+            print(error)
+        print("\nSee README.md for setup instructions")
+        sys.exit(1)
+    else:
+        print("✓ ALL TESTS PASSED")
+        print("=" * 60)
+        print("\nYou can now run:")
+        print("  python 01_basic_workflow.py")
+        print("  python 02_data_exploration.py")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/openspec/changes/add-ckan-host-allowlist-env/design.md

@@ -0,0 +1,38 @@
+# Design: CKAN Host Allowlist via Environment
+
+## Overview
+Introduce an optional, environment-driven allowlist for CKAN hosts. When configured, all CKAN requests must target hosts in the allowlist. When not configured, behavior remains unchanged.
+
+## Configuration
+- Environment variable: `ALLOWED_CKAN_HOSTS`
+- Format: comma-separated hostnames (e.g., `dati.gov.it,data.gov,catalog.data.gov`)
+- Parsing rules:
+  - Split on commas
+  - Trim whitespace
+  - Lowercase
+  - Drop empty entries
+
+## Enforcement
+- Validate hostnames extracted from:
+  - Tool inputs: `server_url`
+  - Resource URIs: `ckan://{server}/...`
+- Reject requests where the hostname is not in the allowlist.
+- Error message should be explicit: `Host not allowed: <hostname>`.
+
+## Runtime Scope
+- Node.js (stdio/http) and Workers runtimes share the same validation utility.
+- Workers reads env via `env.ALLOWED_CKAN_HOSTS` (wrangler var), Node via `process.env.ALLOWED_CKAN_HOSTS`.
+
+## Integration Points
+- Add a small utility module, e.g. `src/utils/allowlist.ts`:
+  - `parseAllowedHosts(value?: string): Set<string> | null`
+  - `assertAllowedHost(serverUrl: string, allowed: Set<string> | null): void`
+- Call `assertAllowedHost` inside CKAN request flow or immediately in each tool/resource handler before network calls.
+
+## Backwards Compatibility
+- If `ALLOWED_CKAN_HOSTS` is unset or empty, allow all hosts (no behavior change).
+
+## Testing
+- Unit tests for parsing behavior (case, whitespace, empty entries).
+- Unit tests for allow/deny logic with known hostnames and invalid URLs.
+- Tool/resource tests to verify rejection when allowlist is set.

package/openspec/changes/add-ckan-host-allowlist-env/proposal.md

@@ -0,0 +1,16 @@
+# Change: Add allowlist for CKAN hosts via environment
+
+## Why
+Public HTTP/Workers deployments can be abused to proxy requests to arbitrary hosts. A host allowlist provides a simple, configurable barrier without breaking local usage.
+
+## What Changes
+- Add `ALLOWED_CKAN_HOSTS` env var (comma-separated hostnames) to restrict `server_url` targets.
+- Validate `server_url` host against the allowlist for all tools/resources that call CKAN.
+- Document and expose the env var in `wrangler.toml` for Workers deployments.
+
+## Design Reference
+See `openspec/changes/add-ckan-host-allowlist-env/design.md` for configuration, enforcement, and runtime details.
+
+## Impact
+- Affected specs: `cloudflare-deployment`, new `ckan-request-allowlist`
+- Affected code: request validation utilities; Workers/Node configuration handling; tools/resources that accept `server_url` or `ckan://` URIs.

package/openspec/changes/add-ckan-host-allowlist-env/specs/ckan-request-allowlist/spec.md

@@ -0,0 +1,15 @@
+## ADDED Requirements
+### Requirement: CKAN host allowlist validation
+The system SHALL validate every CKAN request target against an optional allowlist configured via `ALLOWED_CKAN_HOSTS`.
+
+#### Scenario: Allowed host
+- **WHEN** a tool or resource is called with a `server_url` whose hostname is in `ALLOWED_CKAN_HOSTS`
+- **THEN** the request proceeds as normal
+
+#### Scenario: Disallowed host
+- **WHEN** a tool or resource is called with a `server_url` whose hostname is not in `ALLOWED_CKAN_HOSTS`
+- **THEN** the request is rejected with a clear error indicating the host is not allowed
+
+#### Scenario: Allowlist not set
+- **WHEN** `ALLOWED_CKAN_HOSTS` is unset or empty
+- **THEN** the system accepts any valid `server_url`

package/openspec/changes/add-ckan-host-allowlist-env/specs/cloudflare-deployment/spec.md

@@ -0,0 +1,11 @@
+## ADDED Requirements
+### Requirement: Workers allowlist configuration
+The system SHALL allow configuring an allowlist of CKAN hosts for Workers deployments via environment variable.
+
+#### Scenario: Wrangler allowlist configuration
+- **WHEN** `wrangler.toml` sets `ALLOWED_CKAN_HOSTS` to a comma-separated list of hostnames
+- **THEN** the Workers runtime reads the variable and restricts CKAN requests to those hosts
+
+#### Scenario: Allowlist not set
+- **WHEN** `ALLOWED_CKAN_HOSTS` is unset or empty in the Workers environment
+- **THEN** the Workers runtime allows requests to any CKAN host

package/openspec/changes/add-ckan-host-allowlist-env/tasks.md

@@ -0,0 +1,12 @@
+## 1. Implementation
+- [ ] Add allowlist parsing utility for `ALLOWED_CKAN_HOSTS` (comma-separated hostnames, case-insensitive, trim whitespace).
+- [ ] Enforce allowlist for all CKAN requests (tools and resource templates) with clear error messaging.
+- [ ] Ensure allowlist applies to both Node and Workers runtimes.
+
+## 2. Configuration
+- [ ] Add `ALLOWED_CKAN_HOSTS` to `wrangler.toml` with example values.
+- [ ] Update docs/README to describe the env var and behavior (optional if required by spec).
+
+## 3. Tests
+- [ ] Add unit tests for allowlist parsing and validation.
+- [ ] Add tool/resource tests verifying rejection for non-allowed hosts when env var is set.

package/openspec/changes/add-escape-text-query/proposal.md

@@ -0,0 +1,12 @@
+# Change: Escape text-field query wrapping in search parser
+
+## Why
+Wrapping arbitrary user input in `text:(...)` without escaping allows query parser errors or unintended semantics when the input contains Solr/Lucene metacharacters (e.g., `"` or `)`).
+
+## What Changes
+- Escape Solr/Lucene special characters before wrapping user input in `text:(...)`.
+- Add tests to confirm escaped output and prevent regressions.
+
+## Impact
+- Affected specs: `ckan-search`
+- Affected code: `src/utils/search.ts`, package search tool behavior, related tests.

package/openspec/changes/add-escape-text-query/specs/ckan-search/spec.md

@@ -0,0 +1,11 @@
+## MODIFIED Requirements
+### Requirement: Package search parser override
+The system SHALL support a per-portal default and a per-request override to force package search queries through the `text` field when needed, and SHALL escape Solr/Lucene special characters when wrapping queries in `text:(...)`.
+
+#### Scenario: Portal default applies
+- **WHEN** a portal is configured to force the text-field parser
+- **THEN** `ckan_package_search` uses `text:(...)` for non-fielded queries by default with escaped query content
+
+#### Scenario: Request override applies
+- **WHEN** a client explicitly requests the text-field parser
+- **THEN** `ckan_package_search` uses `text:(...)` regardless of portal defaults with escaped query content

package/openspec/changes/add-escape-text-query/tasks.md

@@ -0,0 +1,8 @@
+## 1. Implementation
+- [x] Add a Solr/Lucene escaping helper for text-field queries.
+- [x] Apply escaping when `resolveSearchQuery` forces `text:(...)`.
+- [x] Ensure behavior is unchanged when not forcing the text parser.
+
+## 2. Tests
+- [x] Add unit tests for escaping behavior (quotes, parentheses, backslashes, colons).
+- [x] Add tests to cover `resolveSearchQuery` effectiveQuery output with forced text parser.

package/openspec/changes/archive/2026-01-15-add-mcp-resource-filters/proposal.md

@@ -0,0 +1,13 @@
+# Change: add filtered CKAN dataset resource templates
+
+## Why
+Users need quick, direct access to filtered dataset lists (by theme, publisher, tag, format) without building complex tool queries.
+
+## What Changes
+- Add new MCP resource templates under the existing `ckan://{server}/...` scheme for group, organization, tag, and format dataset filters.
+- Extend resource discovery to list the new templates.
+- Document new resource URIs and examples.
+
+## Impact
+- Affected specs: mcp-resources
+- Affected code: `src/resources/*`, `src/resources/uri.ts`, README/docs

package/openspec/changes/archive/2026-01-15-add-mcp-resource-filters/specs/mcp-resources/spec.md

@@ -0,0 +1,38 @@
+## ADDED Requirements
+
+### Requirement: Group Datasets Resource Template
+The system SHALL expose a resource template for accessing CKAN datasets by group via the URI pattern `ckan://{server}/group/{name}/datasets`.
+
+#### Scenario: Read datasets by group
+- **WHEN** client reads `ckan://dati.gov.it/group/governo/datasets`
+- **THEN** server returns JSON with the matching datasets from `package_search`
+
+### Requirement: Organization Datasets Resource Template
+The system SHALL expose a resource template for accessing CKAN datasets by organization via the URI pattern `ckan://{server}/organization/{name}/datasets`.
+
+#### Scenario: Read datasets by organization
+- **WHEN** client reads `ckan://dati.gov.it/organization/regione-toscana/datasets`
+- **THEN** server returns JSON with the matching datasets from `package_search`
+
+### Requirement: Tag Datasets Resource Template
+The system SHALL expose a resource template for accessing CKAN datasets by tag via the URI pattern `ckan://{server}/tag/{name}/datasets`.
+
+#### Scenario: Read datasets by tag
+- **WHEN** client reads `ckan://dati.gov.it/tag/turismo/datasets`
+- **THEN** server returns JSON with the matching datasets from `package_search`
+
+### Requirement: Format Datasets Resource Template
+The system SHALL expose a resource template for accessing CKAN datasets by resource format via the URI pattern `ckan://{server}/format/{format}/datasets`.
+
+#### Scenario: Read datasets by format
+- **WHEN** client reads `ckan://dati.gov.it/format/csv/datasets`
+- **THEN** server returns JSON with the matching datasets from `package_search` filtered by resource format
+
+## MODIFIED Requirements
+
+### Requirement: Resource Discovery
+The system SHALL list available resource templates when client requests resource list, including dataset, resource, organization, and dataset filter templates (group, organization, tag, format).
+
+#### Scenario: List resource templates
+- **WHEN** client calls `resources/listTemplates`
+- **THEN** server returns list of available URI templates with descriptions, including the dataset filter templates

package/openspec/changes/archive/2026-01-15-add-mcp-resource-filters/tasks.md

@@ -0,0 +1,10 @@
+## 1. Implementation
+- [x] Add new resource handlers for group, organization datasets, tag, and format filters under `src/resources/`.
+- [x] Register new resource templates in `src/resources/index.ts`.
+- [x] Update URI parsing/validation to accept the new dataset filter paths.
+- [x] Add tests for each new resource template and error cases.
+- [x] Update README/docs with new `ckan://{server}/...` examples.
+
+## 2. Validation
+- [x] Run `npm test` (or targeted resource tests).
+- [x] Run `openspec validate add-mcp-resource-filters --strict`.

package/openspec/changes/archive/2026-01-19-update-repo-owner-ondata/proposal.md

@@ -0,0 +1,13 @@
+# Change: Move repository ownership to ondata organization
+
+## Why
+The repository is moving from the personal account to the ondata organization. Documentation, badges, and published references must reflect the new canonical URL to avoid confusion and broken links.
+
+## What Changes
+- Update documentation and in-app links to the new repository URL under the ondata organization.
+- Preserve npm package ownership and scope as @aborruso (no npm ownership change).
+- Confirm GitHub Pages and related references align with the new organization ownership.
+
+## Impact
+- Affected specs: repository-metadata, cloudflare-deployment (docs references)
+- Affected code: README.md, docs/*, src/worker.ts, .github/ISSUE_TEMPLATE/config.yml

package/openspec/changes/archive/2026-01-19-update-repo-owner-ondata/specs/repository-metadata/spec.md

@@ -0,0 +1,14 @@
+## ADDED Requirements
+### Requirement: Canonical repository ownership references
+The project documentation and UI MUST reference the canonical repository under the ondata organization once the repository is migrated.
+
+#### Scenario: Repository references updated
+- **WHEN** a user follows documentation or UI links to the repository
+- **THEN** the links point to the ondata organization repository URL
+
+### Requirement: NPM package ownership remains personal
+The project MUST continue to document the npm package under the @aborruso scope unless an explicit npm ownership change is approved.
+
+#### Scenario: npm install instructions unchanged
+- **WHEN** a user follows installation instructions
+- **THEN** the package name remains @aborruso/ckan-mcp-server