workspaces-euc-mcp-server 0.1.1__py3-none-any.whl

workspaces_euc_mcp_server/tools/secure_browser.py

@@ -0,0 +1,190 @@
+# Copyright bengroeneveldsg. Licensed under the Apache License, Version 2.0 (the "License").
+# You may not use this file except in compliance with the License.
+# A copy of the License is located at http://www.apache.org/licenses/LICENSE-2.0
+"""WorkSpaces Secure Browser (formerly WorkSpaces Web) tools (read-only, IAM Tier 0).
+
+Brings Secure Browser to parity with the other services:
+- ``get_secure_browser_portal_details`` resolves a portal's user/browser/network/data-protection
+  settings — the clipboard/print/download data-egress controls that matter for security. Available
+  and validatable now.
+- ``get_secure_browser_portal_usage`` returns session metrics from AWS/WorkSpacesWeb. Unlike the
+  WorkSpaces capacity metrics, Secure Browser only emits these when sessions occur, so it is empty
+  for idle portals; the metric names follow AWS docs and are best-effort until there is activity.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .. import consts
+from ..clients import ClientFactory
+from ..models import SecureBrowserPortalDetails, ServiceError, UsageHistory
+from ._common import read_only, try_call
+from .performance import _fetch_metric_series
+
+
+def get_secure_browser_portal_details_core(
+    factory: ClientFactory, portal_arn: str, region: str | None
+) -> SecureBrowserPortalDetails:
+    errors: list[ServiceError] = []
+    web = factory.client(consts.SECURE_BROWSER_API, region=region)
+
+    portal = try_call(
+        errors,
+        consts.PRODUCT_SECURE_BROWSER,
+        "GetPortal",
+        lambda: web.get_portal(portalArn=portal_arn).get("portal", {}),
+        default={},
+    )
+
+    user_settings: dict[str, object] = {}
+    if portal.get("userSettingsArn"):
+        us = try_call(
+            errors,
+            consts.PRODUCT_SECURE_BROWSER,
+            "GetUserSettings",
+            lambda: web.get_user_settings(userSettingsArn=portal["userSettingsArn"]).get(
+                "userSettings", {}
+            ),
+            default={},
+        )
+        # Keep the policy-relevant flags; drop bulky/identifying fields.
+        for key in (
+            "copyAllowed",
+            "pasteAllowed",
+            "downloadAllowed",
+            "uploadAllowed",
+            "printAllowed",
+            "deepLinkAllowed",
+            "webAuthnAllowed",
+            "disconnectTimeoutInMinutes",
+            "idleDisconnectTimeoutInMinutes",
+        ):
+            if key in (us or {}):
+                user_settings[key] = us[key]
+
+    network: dict[str, object] = {}
+    if portal.get("networkSettingsArn"):
+        ns = try_call(
+            errors,
+            consts.PRODUCT_SECURE_BROWSER,
+            "GetNetworkSettings",
+            lambda: web.get_network_settings(networkSettingsArn=portal["networkSettingsArn"]).get(
+                "networkSettings", {}
+            ),
+            default={},
+        )
+        for key in ("vpcId", "subnetIds", "securityGroupIds"):
+            if key in (ns or {}):
+                network[key] = ns[key]
+
+    return SecureBrowserPortalDetails(
+        portal_arn=portal_arn,
+        display_name=portal.get("displayName"),
+        authentication_type=portal.get("authenticationType"),
+        status=portal.get("portalStatus"),
+        user_settings=user_settings,
+        network=network,
+        has_browser_policy=bool(portal.get("browserSettingsArn")),
+        has_data_protection=bool(portal.get("dataProtectionSettingsArn")),
+        errors=errors,
+    )
+
+
+def _portal_id(portal: str) -> str:
+    """Accept a portal ARN or id; the CloudWatch dimension uses the id (last ARN segment)."""
+    return portal.rsplit("/", 1)[-1] if "/" in portal else portal
+
+
+def get_secure_browser_portal_usage_core(
+    factory: ClientFactory,
+    portal: str,
+    region: str | None,
+    lookback_days: int = 7,
+    period_hours: int = 24,
+) -> UsageHistory:
+    errors: list[ServiceError] = []
+    cloudwatch = factory.client(consts.CLOUDWATCH_API, region=region)
+    metrics = try_call(
+        errors,
+        "Amazon CloudWatch",
+        "GetMetricData",
+        lambda: _fetch_metric_series(
+            cloudwatch,
+            consts.SECURE_BROWSER_NAMESPACE,
+            consts.SECURE_BROWSER_PORTAL_DIMENSION,
+            _portal_id(portal),
+            consts.SECURE_BROWSER_SESSION_METRICS,
+            lookback_days,
+            period_hours,
+        ),
+        default={},
+    )
+    summary = (
+        "No session metrics in the window. Secure Browser only emits CloudWatch metrics when "
+        "sessions occur (idle portals publish nothing); for detailed usage enable the portal's "
+        "Session Logger."
+        if not metrics
+        else f"Session metrics over {lookback_days}d: see series."
+    )
+    return UsageHistory(
+        target_type=consts.PRODUCT_SECURE_BROWSER,
+        target_id=portal,
+        lookback_days=lookback_days,
+        period_hours=period_hours,
+        metrics=metrics or {},
+        summary=summary,
+        errors=errors,
+    )
+
+
+def register(mcp: Any, factory: ClientFactory) -> None:
+    """Register Secure Browser tools on the FastMCP app."""
+
+    async def get_secure_browser_portal_details(
+        portal_arn: str, region: str | None = None
+    ) -> dict[str, Any]:
+        """Resolve a WorkSpaces Secure Browser portal's settings (security-relevant).
+
+        Returns the portal's user settings (clipboard copy/paste, file download/upload, print
+        controls + timeouts), network (VPC/subnets/security groups), and whether a browser policy
+        and data-protection settings are attached. Read-only.
+
+        Args:
+            portal_arn: The portal ARN (from get_euc_inventory_summary / generate_inventory_report).
+            region: AWS region. Defaults to the server's configured region.
+        """
+        details = get_secure_browser_portal_details_core(
+            factory, portal_arn, region or factory.region
+        )
+        return details.model_dump()
+
+    async def get_secure_browser_portal_usage(
+        portal: str,
+        region: str | None = None,
+        lookback_days: int = 7,
+        period_hours: int = 24,
+    ) -> dict[str, Any]:
+        """Get a Secure Browser portal's session metrics (AWS/WorkSpacesWeb) over a window.
+
+        NOTE: Secure Browser only emits these metrics when sessions occur, so idle portals return
+        nothing; richer per-session data is available via the portal's Session Logger. Read-only.
+
+        Args:
+            portal: The portal id or ARN.
+            region: AWS region. Defaults to the server's configured region.
+            lookback_days: Window length (default 7).
+            period_hours: Bucket size in hours (default 24).
+        """
+        usage = get_secure_browser_portal_usage_core(
+            factory, portal, region or factory.region, lookback_days, period_hours
+        )
+        return usage.model_dump()
+
+    mcp.add_tool(
+        get_secure_browser_portal_details,
+        annotations=read_only("Secure Browser portal details"),
+    )
+    mcp.add_tool(
+        get_secure_browser_portal_usage, annotations=read_only("Secure Browser portal usage")
+    )

workspaces_euc_mcp_server-0.1.1.dist-info/METADATA

@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: workspaces-euc-mcp-server
+Version: 0.1.1
+Summary: MCP server for administering the Amazon WorkSpaces family of End User Computing services (Personal, Pools, Applications, Secure Browser, Core).
+Project-URL: Homepage, https://github.com/bengroeneveldsg/aws-workspaces-euc-mcp
+Project-URL: Repository, https://github.com/bengroeneveldsg/aws-workspaces-euc-mcp
+Project-URL: Issues, https://github.com/bengroeneveldsg/aws-workspaces-euc-mcp/issues
+Author: bengroeneveldsg
+License: Apache-2.0
+License-File: LICENSE
+Keywords: amazon-workspaces,appstream,aws,end-user-computing,euc,mcp,model-context-protocol
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: boto3>=1.34.0
+Requires-Dist: loguru>=0.7.2
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: pydantic>=2.6.0
+Provides-Extra: dev
+Requires-Dist: bandit>=1.7; extra == 'dev'
+Requires-Dist: pre-commit>=3.6; extra == 'dev'
+Requires-Dist: pyright>=1.1; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# WorkSpaces EUC MCP Server
+
+[![CI](https://github.com/bengroeneveldsg/aws-workspaces-euc-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/bengroeneveldsg/aws-workspaces-euc-mcp/actions/workflows/ci.yml)
+
+An [MCP](https://modelcontextprotocol.io) server that gives administrators AI-assisted
+**inventory, troubleshooting, and cost/utilization optimization** across the Amazon WorkSpaces
+End User Computing (EUC) portfolio:
+
+- **Amazon WorkSpaces Personal** — persistent virtual desktops
+- **Amazon WorkSpaces Pools** — non-persistent pooled desktops
+- **Amazon WorkSpaces Applications** — application streaming (formerly AppStream 2.0)
+- **Amazon WorkSpaces Secure Browser** — managed browser (formerly WorkSpaces Web)
+- **Amazon WorkSpaces Core** — partner / bring-your-own VDI integration, incl. **Core Managed
+  Instances** (the `workspaces-instances` API). Plain Core partner desktops appear via the standard
+  WorkSpaces API and are counted under WorkSpaces Personal.
+
+**Legacy names are accepted.** Ask using former names and the tools still route correctly, while
+output always uses the current name: **AppStream / AppStream 2.0 → Amazon WorkSpaces Applications**
+(same service, the `appstream` API), and **WorkSpaces Web → Amazon WorkSpaces Secure Browser**.
+
+> Built for the **administrator** persona, following the
+> [official AWS MCP design conventions](https://github.com/awslabs/mcp) (Python, FastMCP,
+> Pydantic, boto3). It is **read-only by default** and **security-first**: write/lifecycle tools
+> are opt-in, gated behind explicit flags and matching IAM permissions.
+
+## Why this exists
+
+Generic AWS MCP servers can already call EUC APIs one-to-one. This server is different: its tools
+are **cross-service workflows** that synthesize a result (an inventory rollup, a connectivity
+diagnosis, a right-sizing recommendation) instead of returning raw API output. See
+[`DESIGN.md`](DESIGN.md) for the full tool inventory and roadmap.
+
+## Status
+
+**Phase 1 (in progress)** — read-only inventory and troubleshooting tools:
+
+| Tool | Description |
+|------|-------------|
+| `get_euc_inventory_summary` | Cross-service inventory for a region (incl. **WorkSpaces Core Managed Instances**): per-service counts by state, grand total, and any per-service collection errors. |
+| `diagnose_workspace_connectivity` | Why a WorkSpaces Personal desktop may be unreachable — correlates WorkSpace state, connection status, directory health, and CloudWatch connection metrics into a ranked diagnosis. |
+| `diagnose_application_fleet` | A WorkSpaces Applications fleet's health and capacity — fleet state, fleet errors, compute capacity, auto-scaling activity, and insufficient-capacity errors. |
+| `diagnose_pool` | A WorkSpaces Pool's health — state, pool errors, user-session capacity, backing directory health, and session-utilization. |
+| `get_application_fleet_usage` | A WorkSpaces Applications fleet's **usage history** — AWS/AppStream capacity/utilization time-series over a window, with a plain-language summary (e.g. idle running capacity) (Tier 0). |
+| `check_directory_health` | Registration state and AWS Directory Service stage for one or all WorkSpaces-registered directories. |
+| `analyze_workspace_utilization` | Classifies WorkSpaces Personal desktops as unused / idle / active from the `UserConnected` metric (Tier 1). |
+| `recommend_running_mode` | Flags AlwaysOn desktops with low usage as AutoStop candidates, with an **estimated $/mo saving** where the bundle price can be matched (Tier 1). |
+| `get_workspace_performance` | Native CPU / memory / disk / GPU / latency / uptime metrics per desktop from `AWS/WorkSpaces` — no CloudWatch agent (Tier 0). |
+| `get_workspace_connection_history` | A desktop's connection/session **history** (UserConnected + connection attempts/failures) over a window, with a summary (Tier 0). |
+| `get_pool_session_history` | A WorkSpaces Pool's user-**session history** (active/available/utilization capacity time-series), flags idle pool capacity (Tier 0). |
+| `recommend_bundle_rightsizing` | Suggests smaller/larger compute types from CPU & memory headroom (general families; graphics excluded) (Tier 0). |
+| `get_euc_cost_summary` | EUC spend by service over a window via Cost Explorer, account-wide (Tier 1). |
+| `generate_inventory_report` | Detailed per-resource inventory (desktops **with assigned user / computer name / IP**, pools, fleets, **stacks + their associated fleets**, portals) with key attributes (Tier 0). |
+| `audit_security_posture` | Cross-service: flags unencrypted WorkSpace volumes, directories without IP access control groups, and **Secure Browser portals / Applications stacks that allow data egress** (clipboard/download/print) (Tier 0). |
+| `get_secure_browser_portal_details` | Resolves a Secure Browser portal's user settings (clipboard/print/download controls + timeouts), network, and attached policies (Tier 0). |
+| `get_secure_browser_portal_usage` | A Secure Browser portal's `AWS/WorkSpacesWeb` session metrics over a window (empty until the portal has sessions; Session Logger gives detail) (Tier 0). |
+| `list_unused_resources` | Unused WorkSpaces desktops and stopped/zero-capacity fleets worth reclaiming (Tier 0). |
+
+Cost/utilization tools need the **Tier 1** IAM policy ([`iam/tier1-cost.json`](iam/tier1-cost.json));
+everything else above is **Tier 0** ([`iam/tier0-diagnostics.json`](iam/tier0-diagnostics.json)).
+
+### Write tools — opt-in, guarded (Phase 2, Tier 2)
+
+Registered **only** when launched with `--enable-writes`, and need the **Tier 2** policy
+([`iam/tier2-lifecycle.json`](iam/tier2-lifecycle.json)). Every mutation is **dry-run by default**
+(returns a plan, changes nothing) unless called with `confirm=true`, and confirmed bulk actions are
+**refused above `--max-bulk-targets`**.
+
+| Tool | Description |
+|------|-------------|
+| `start_workspaces` / `stop_workspaces` / `reboot_workspaces` | Power operations on WorkSpaces Personal desktops (batch, capped). |
+| `modify_workspace_running_mode` | Switch a desktop between `AUTO_STOP` and `ALWAYS_ON`. |
+| `start_workspaces_pool` / `stop_workspaces_pool` | Power a WorkSpaces Pool on/off. |
+| `update_workspaces_pool_capacity` | Set a Pool's desired user-session capacity. |
+| `start_application_fleet` / `stop_application_fleet` | Power a WorkSpaces Applications fleet on/off. |
+| `update_application_fleet_capacity` | Set a fleet's desired instance capacity. |
+
+### Destructive tools — double opt-in, typed acknowledgement (Phase 3, Tier 3)
+
+Registered **only** with both `--enable-writes` **and** `--enable-destructive`, and need the
+**Tier 3** policy ([`iam/tier3-destructive.json`](iam/tier3-destructive.json)). On top of the
+dry-run default and blast-radius cap, each execution requires an **exact typed acknowledgement**.
+
+| Tool | Description | Acknowledge |
+|------|-------------|-------------|
+| `terminate_workspaces` | **Permanently delete** desktops (irreversible). | `"TERMINATE"` |
+| `rebuild_workspaces` | Reset root volume to bundle; user volume from last snapshot. | `"REBUILD"` |
+| `restore_workspace` | Restore a desktop from its last snapshot. | `"RESTORE"` |
+
+Example: `terminate_workspaces(workspace_ids=[...], confirm=true, acknowledge="TERMINATE")`.
+Without the exact phrase the call is **refused** and nothing changes. See [`DESIGN.md`](DESIGN.md).
+
+## Requirements
+
+- Python 3.11+
+- AWS credentials available via the standard chain (`AWS_PROFILE`, `AWS_REGION`, SSO, or an
+  assumed role).
+- An IAM identity with the **Tier 0** policy in [`iam/tier0-diagnostics.json`](iam/tier0-diagnostics.json).
+
+## Credentials & data handling
+
+This server is built to be redistributed and run by many parties, so it **never stores or embeds
+any user-specific data**:
+
+- **Credentials** come only from the standard AWS chain at runtime — they are never read into,
+  logged by, or persisted by the server.
+- **No state on disk.** There is no config/cache/state file; boto3 clients live in memory only.
+- **No account-specific data in the code** — no account IDs, ARNs, profile names, or regions are
+  hardcoded. Provide them at runtime via flags/env. Documentation uses placeholders only.
+
+Bring your own credentials and region; the server holds nothing.
+
+## Install
+
+With [`uv`](https://docs.astral.sh/uv/) (recommended once published):
+
+```bash
+uvx workspaces-euc-mcp-server@latest
+```
+
+From source:
+
+```bash
+python -m venv .venv
+# Windows: .venv\Scripts\Activate.ps1   |   macOS/Linux: source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+## Configure your MCP client
+
+```json
+{
+  "mcpServers": {
+    "workspaces-euc": {
+      "command": "uvx",
+      "args": ["workspaces-euc-mcp-server@latest"],
+      "env": {
+        "AWS_PROFILE": "your-euc-admin-profile",
+        "AWS_REGION": "us-east-1"
+      }
+    }
+  }
+}
+```
+
+Running from a source checkout instead of `uvx`:
+
+```json
+{
+  "mcpServers": {
+    "workspaces-euc": {
+      "command": "python",
+      "args": ["-m", "workspaces_euc_mcp_server.server", "--region", "us-east-1"],
+      "env": { "AWS_PROFILE": "your-euc-admin-profile" }
+    }
+  }
+}
+```
+
+## Command-line flags
+
+| Flag | Default | Purpose |
+|------|---------|---------|
+| `--region` | session/profile region | Target AWS region. |
+| `--profile` | default chain | AWS named profile. |
+| `--assume-role-arn` | none | Cross-account role to assume (multi-account / MSP). |
+| `--external-id` | none | ExternalId for the assumed role, if required. |
+| `--enable-writes` | off | Register Phase 2 lifecycle (write) tools. |
+| `--enable-destructive` | off | Allow terminate/rebuild/restore (requires `--enable-writes`). |
+| `--max-bulk-targets` | 25 | Blast-radius cap for bulk mutations (Phase 2). |
+
+The server starts **read-only**; mutating tools require both the launch flag **and** the matching
+IAM tier.
+
+## Multi-account / MSP
+
+To manage a **different** account from the one your credentials live in, launch with
+`--assume-role-arn` (and `--external-id` if the role requires it):
+
+```bash
+workspaces-euc-mcp-server --region ap-southeast-1 \
+  --assume-role-arn arn:aws:iam::222222222222:role/EucReadOnly --external-id my-ext-id
+```
+
+The server transparently `sts:AssumeRole`s into the target account and auto-refreshes the
+credentials. Requirements:
+- The launching identity needs `sts:AssumeRole` on the target role.
+- The **target role** needs the matching tier policy from [`iam/`](iam/) (Tier 0 for read-only).
+- To manage many accounts, run one instance per target role (or point separate MCP-client entries
+  at different `--assume-role-arn` values).
+
+## IAM
+
+Attach [`iam/tier0-diagnostics.json`](iam/tier0-diagnostics.json) to the identity the server runs
+as (or to the role you assume with `--assume-role-arn`). Tiers are additive and documented in [`iam/README.md`](iam/README.md). All actions are
+captured by AWS CloudTrail.
+
+## Example admin questions
+
+Once the server is connected to an MCP client, you can ask in natural language and the client will
+pick the right tool. A few examples:
+
+| You ask… | Tool the client uses |
+|----------|----------------------|
+| "What WorkSpaces resources do I have in us-east-1?" | `get_euc_inventory_summary` |
+| "User X can't connect to ws-abc123 — why?" | `diagnose_workspace_connectivity` |
+| "Is the marketing AppStream fleet healthy / out of capacity?" | `diagnose_application_fleet` |
+| "Which desktops are idle or unused this fortnight?" | `analyze_workspace_utilization` / `list_unused_resources` |
+| "Where can I cut WorkSpaces cost?" | `recommend_running_mode` + `get_euc_cost_summary` |
+| "Any desktops without volume encryption or IP restrictions?" | `audit_security_posture` |
+| "Switch ws-abc123 to AutoStop." | `modify_workspace_running_mode` (dry-run first) |
+| "Reboot these three stuck desktops." | `reboot_workspaces` (dry-run, then `confirm=true`) |
+
+**Write/destructive tools are off unless enabled.** Mutations show a dry-run plan first; to execute
+you pass `confirm=true` (and, for destructive ops, the exact acknowledge phrase). For example, a
+full destructive run looks like:
+
+```text
+terminate_workspaces(workspace_ids=["ws-abc123"], confirm=true, acknowledge="TERMINATE")
+```
+
+Launch with writes/destructive enabled:
+
+```bash
+workspaces-euc-mcp-server --enable-writes                      # Tier 2 power/capacity tools
+workspaces-euc-mcp-server --enable-writes --enable-destructive # + Tier 3 terminate/rebuild/restore
+```
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest            # run tests (deterministic, no AWS account needed)
+ruff check .      # lint
+ruff format .     # format
+pyright           # type check
+```
+
+## License
+
+Apache-2.0. See [`LICENSE`](LICENSE).

workspaces_euc_mcp_server-0.1.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+workspaces_euc_mcp_server/__init__.py,sha256=vN9aSy6oLrmsT8LGOYSsuc_NkIQPBtj0XKebpNbL4rg,351
+workspaces_euc_mcp_server/clients.py,sha256=JgLC2ohayDGCnmRetkEKKC03ropxBfgPADrVEOMTHiw,4310
+workspaces_euc_mcp_server/consts.py,sha256=by0n12xjbtGoFVR_9kF0tTeHa9AUt7am3RAVtfrEXDI,7653
+workspaces_euc_mcp_server/models.py,sha256=H9S4Ocyb6cHf1DnZU6BPqzpMmyTeorCY8IxCo_qWfiQ,11697
+workspaces_euc_mcp_server/server.py,sha256=cDz3bAWx5vbtRHxDdFxwvgSeQea4FZ2fN_A9kqzoMkY,4201
+workspaces_euc_mcp_server/tools/__init__.py,sha256=BXnj7fvAQksDdnNkwRIK_AqbEJbdBZHxCZNdo0rSpeE,297
+workspaces_euc_mcp_server/tools/_common.py,sha256=rOOQw3VZwKXe7LPAfIUgyABH930jCTx6EMlseNBUqjM,2897
+workspaces_euc_mcp_server/tools/cost.py,sha256=uy3vczQXpLAOgy3LKogy4qPrxZGeWK8xrLs01QHM1cg,12283
+workspaces_euc_mcp_server/tools/destructive.py,sha256=FqEbZT8gn0RJatSyYP3bCBaFWARRwRONgURynTOli7Y,10538
+workspaces_euc_mcp_server/tools/diagnostics.py,sha256=YZ_-NE-smwNvuI-9rGRZQHX0wG3sKCpAiUyZ_5c_tv4,29409
+workspaces_euc_mcp_server/tools/inventory.py,sha256=zW73ZgcvczAZnUfQ18lImZwcOj9VcXzm9HUyBdIG3Bs,5607
+workspaces_euc_mcp_server/tools/lifecycle.py,sha256=8SkLAVw06Ssop4GQemgazJNBO_vqhEn8Po0kJAj1L2Q,20470
+workspaces_euc_mcp_server/tools/performance.py,sha256=esTptr_6qPEo2LeTp02CHRwnEn212N0GTL1qh0Hrhm8,23770
+workspaces_euc_mcp_server/tools/pricing.py,sha256=VLUc2Uwbey9pLrDSlUZdDdIn6vN4RgTMSvB1i___Wo0,6042
+workspaces_euc_mcp_server/tools/reporting.py,sha256=vIwrW_pSxASdBcd3PusXjMiZmNXGaN5JSHU7GxQV0ZU,20839
+workspaces_euc_mcp_server/tools/secure_browser.py,sha256=Zo9u1OELoJ4j67_NgaNdTvmQuYS4SxRFY9wcbmiLgpI,7087
+workspaces_euc_mcp_server-0.1.1.dist-info/METADATA,sha256=RDH6DL6TQKo1g3uJi7b9D8-StQ503u4gDFzj8L9nbkc,14056
+workspaces_euc_mcp_server-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+workspaces_euc_mcp_server-0.1.1.dist-info/entry_points.txt,sha256=1DxnZ045NekJuyDPYZb4GVBuNBFZ23tapUe4u3oK5Pc,84
+workspaces_euc_mcp_server-0.1.1.dist-info/licenses/LICENSE,sha256=23MygUoAYVsCVggnjcHMUxSCCbqqTXEHPl9nysgvl54,11357
+workspaces_euc_mcp_server-0.1.1.dist-info/RECORD,,

workspaces_euc_mcp_server-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

workspaces_euc_mcp_server-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+workspaces-euc-mcp-server = workspaces_euc_mcp_server.server:main