stacklet-mcp 0.1.0__tar.gz

stacklet_mcp-0.1.0/.github/CODEOWNERS

@@ -0,0 +1 @@
+* @stacklet/engineering

stacklet_mcp-0.1.0/.github/composites/install/action.yml

@@ -0,0 +1,31 @@
+name: Common setup
+description: common setup for actions
+runs:
+  using: composite
+  steps:
+    - name: Tool versions
+      uses: wistia/parse-tool-versions@v2.1.1
+      with:
+        prefix: TOOL_VERSION_
+
+    - name: Setup Just
+      uses: extractions/setup-just@v3
+      with:
+        just-version: ${{ env.TOOL_VERSION_JUST }}
+
+    - name: Setup Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ env.TOOL_VERSION_PYTHON }}
+
+    - name: Setup uv
+      uses: astral-sh/setup-uv@v6
+      with:
+        version: ${{ env.TOOL_VERSION_UV }}
+        activate-environment: true
+        enable-cache: true
+
+    - name: Install dependencies
+      shell: sh
+      run: |
+        just install

stacklet_mcp-0.1.0/.github/dependabot.yaml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: weekly

stacklet_mcp-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+name: "CI"
+
+on:
+  push:
+    branches:
+      - main
+      - release/**
+  pull_request:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Install
+        uses: ./.github/composites/install
+
+      - name: Lint
+        run: |
+          just lint
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Install
+        uses: ./.github/composites/install
+
+      - name: Unit tests
+        run: |
+          just test-coverage

stacklet_mcp-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,26 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v[0-9]+.[0-9]+.[0-9]+"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Install
+        uses: ./.github/composites/install
+
+      - name: Build packages
+        run: |
+          uv build
+
+      - name: Publish packges to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

stacklet_mcp-0.1.0/.gitignore

@@ -0,0 +1,21 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.coverage
+.coverage.*
+.pytest_cache/
+
+# IDE
+.vscode/*
+!.vscode/settings.json
+!.vscode/launch.json
+*.swp
+*.swo
+
+# OS
+.DS_Store
+
+# Local config
+.mcp.json

stacklet_mcp-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,41 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: debug-statements
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.7
+    hooks:
+      - id: ruff-check
+        args: [--fix]
+      - id: ruff-format
+
+  - repo: https://github.com/tox-dev/pyproject-fmt
+    rev: v2.6.0
+    hooks:
+      - id: pyproject-fmt
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.13.0
+    hooks:
+      - id: mypy
+        args: [--config-file=pyproject.toml]
+        exclude: ^tests/
+        # some dependencies don't export types, so they're needed in the mypy
+        # virtualenv
+        additional_dependencies:
+          - fastmcp
+          - pydantic
+
+  - repo: https://github.com/arkinmodi/add-license-header
+    rev: v2.4.0
+    hooks:
+      - id: add-license-header
+        args:
+          - --single-year-if-same
+          - --year-delimiter='-'
+          - --license-file=license-header.tpl
+        files: ^.*\.py$

stacklet_mcp-0.1.0/.tool-versions

@@ -0,0 +1,3 @@
+just 1.40.0
+uv 0.8.14
+python 3.12.10

stacklet_mcp-0.1.0/CHANGELOG.md

@@ -0,0 +1,6 @@
+## 0.1.0 - 2025-09-23
+
+- First release
+- Provide AssetDB tools for managing and running SQL queries (both saved and ad-hoc)
+- Provide Platform tools for interacting with the GraphQL API
+- Provide tools for accessing the official documentation

stacklet_mcp-0.1.0/CLAUDE.md

@@ -0,0 +1,207 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is an MCP (Model Context Protocol) server that provides comprehensive tools for interacting with the Stacklet platform. The server exposes tools for documentation access, Stacklet's cloud governance GraphQL API, and AssetDB operations (with some tools conditionally enabled based on configuration).
+
+## Architecture
+
+The codebase follows a modular design with clear separation of concerns:
+
+**Core Components:**
+- `stacklet/mcp/server.py` - Server factory that creates the FastMCP instance
+- `stacklet/mcp/mcp.py` - Main entry point with CLI integration
+- `stacklet/mcp/cmdline.py` - Command line interface with agent config generation
+- `stacklet/mcp/stacklet_auth.py` - Authentication credential loading
+- `stacklet/mcp/utils/` - Utility functions package (text, json, mcp_json, tool helpers)
+- `stacklet/mcp/settings.py` - Server configuration and feature flags
+- `stacklet/mcp/lifespan.py` - Application lifespan management
+
+**Docs Package:**
+- `stacklet/mcp/docs/client.py` - Documentation client for fetching docs from Stacklet deployment
+- `stacklet/mcp/docs/tools.py` - Documentation tool implementations (docs_list, docs_read)
+- `stacklet/mcp/docs/models.py` - Pydantic models for documentation responses
+
+**Platform Package:**
+- `stacklet/mcp/platform/graphql.py` - Platform GraphQL client with instance-level schema caching
+- `stacklet/mcp/platform/tools.py` - Platform tool implementations (platform_graphql_info, platform_graphql_query, platform_dataset_export, etc.)
+- `stacklet/mcp/platform/models.py` - Pydantic models for platform operations (ExportColumn, ExportParam, ConnectionExport, etc.)
+- `stacklet/mcp/platform/graphql_info.md` - Detailed guidance for using the Platform GraphQL API
+- `stacklet/mcp/platform/dataset_info.md` - Guide for exporting large datasets from the Platform API
+
+**AssetDB Package:**
+- `stacklet/mcp/assetdb/redash.py` - AssetDB client using Redash API for SQL queries and saved query management
+- `stacklet/mcp/assetdb/models.py` - Pydantic models specific to AssetDB (Query, User, JobStatus, QueryUpsert, etc.)
+- `stacklet/mcp/assetdb/tools.py` - AssetDB tool implementations (assetdb_query_list, assetdb_sql_query, etc.)
+- `stacklet/mcp/assetdb/sql_info.md` - Comprehensive guide to AssetDB structure and querying best practices
+
+**Authentication Flow:**
+The authentication system echoes the Stacklet Terraform provider's credential resolution:
+1. Environment variables (`STACKLET_ENDPOINT`, `STACKLET_ACCESS_TOKEN`, `STACKLET_IDENTITY_TOKEN`)
+2. Config files saved by the `stacklet-admin` CLI in `~/.stacklet`
+
+Note: `identity_token` is required for AssetDB access via Redash authentication cookies.
+
+**Tool Naming Convention:**
+Tools use component-based prefixes:
+- `platform_*` - Tools for Stacklet's platform GraphQL API
+- `assetdb_*` - Tools for asset database operations (SQL queries and saved query management)
+- Pattern: `{component}_{action}` (e.g., `platform_graphql_query`, `assetdb_sql_query`)
+
+## Development Commands
+
+**Install dependencies:**
+```bash
+uv sync
+# or: just install
+```
+
+**Run the MCP server:**
+```bash
+uv run stacklet-mcp
+# or: just run
+```
+
+**Development commands (via justfile):**
+```bash
+just install      # Install dependencies and generate .mcp.json if needed
+just lint         # Run pre-commit hooks (formatters and linters)
+just test         # Run pytest with optional args
+just test-coverage # Run tests with coverage reporting
+just inspect      # Run MCP inspector tool
+just agent-config # Generate .mcp.json configuration
+```
+
+
+## MCP Tools Available
+
+**Documentation Tools:**
+1. **`docs_list`** - List all available Stacklet user documentation files
+2. **`docs_read`** - Read a specific Stacklet documentation file
+
+**Platform GraphQL Tools:**
+3. **`platform_graphql_info`** - Key information for LLMs using GraphQL tools (call this first)
+4. **`platform_graphql_list_types`** - List the types available in the GraphQL API
+5. **`platform_graphql_get_types`** - Retrieve information about specific GraphQL types
+6. **`platform_graphql_query`** - Execute GraphQL queries against Stacklet platform
+7. **`platform_dataset_info`** - Guide for exporting large datasets
+8. **`platform_dataset_export`** - Export full datasets from GraphQL connections to CSV format
+9. **`platform_dataset_lookup`** - Check the status of dataset exports
+
+**AssetDB Tools:**
+10. **`assetdb_sql_info`** - Key information for LLMs using AssetDB SQL tools (call this first)
+11. **`assetdb_sql_query`** - Execute ad-hoc SQL queries against AssetDB
+12. **`assetdb_query_list`** - List and search saved queries with pagination
+13. **`assetdb_query_get`** - Get detailed information about specific saved queries
+14. **`assetdb_query_result`** - Get results for saved queries with caching control
+15. **`assetdb_query_save`** - Create new queries or update existing ones (conditionally enabled via `STACKLET_MCP_ASSETDB_ALLOW_SAVE=true`)
+16. **`assetdb_query_archive`** - Archive saved queries (conditionally enabled via `STACKLET_MCP_ASSETDB_ALLOW_ARCHIVE=true`)
+
+Total: 16 tools (2 docs + 7 platform + 7 assetdb tools, with 2 assetdb tools conditionally enabled)
+
+The actual tools available are determined by each package's `tools()` function implementation, with some tools conditionally enabled based on server configuration settings.
+
+## Key Implementation Details
+
+**Schema Caching:** The `PlatformClient` class implements instance-level caching to avoid repeated introspection queries, improving performance for schema-heavy operations.
+
+**Client Management:** Both AssetDB and Platform clients use a `.get(ctx)` pattern for lazy initialization and caching in FastMCP context. Credentials are loaded once per session using `StackletCredentials.get(ctx)`.
+
+**Error Handling:** All GraphQL and SQL operations return structured responses, with network errors and JSON parsing errors handled gracefully. AssetDB supports async query polling for long-running operations.
+
+**Credential Security:** Access tokens and identity tokens are never logged or exposed in error messages.
+
+**Platform Integration:** Uses GraphQL API for Stacklet platform operations. The Platform package is organized into:
+- `graphql.py` - Core GraphQL client with schema caching and introspection
+- `tools.py` - FastMCP tool implementations that expose platform functionality (info, list types, get types, query, dataset exports)
+- `models.py` - Pydantic models for exports and GraphQL operations
+Uses `graphql-core` for schema manipulation and SDL generation, enabling proper type introspection and schema documentation.
+
+**AssetDB Integration:** Uses Redash API for SQL query execution and saved query management. The AssetDB package is organized into:
+- `redash.py` - Core client with async operations and authentication
+- `models.py` - Pydantic models for Redash API responses (Query, User, JobStatus, etc.)
+- `tools.py` - FastMCP tool implementations that expose AssetDB functionality
+Supports query timeouts (max 300s), pagination, search, and tag filtering.
+
+## Configuration
+
+**Stacklet Credentials:**
+The server requires Stacklet credentials configured through one of:
+- Environment variables: `STACKLET_ENDPOINT`, `STACKLET_ACCESS_TOKEN`, and `STACKLET_IDENTITY_TOKEN`
+- CLI config: `~/.stacklet/config.json` (endpoint), `~/.stacklet/credentials` (access token), and `~/.stacklet/id` (identity token)
+
+**Server Settings:**
+Additional configuration via environment variables with `STACKLET_MCP_` prefix:
+- `STACKLET_MCP_DOWNLOADS_PATH` (default: system temp directory) - Directory for storing query result files
+- `STACKLET_MCP_ASSETDB_DATASOURCE` (default: 1) - AssetDB data source ID
+- `STACKLET_MCP_ASSETDB_ALLOW_SAVE` (default: false) - Enable query save/update functionality
+- `STACKLET_MCP_ASSETDB_ALLOW_ARCHIVE` (default: false) - Enable query archiving functionality
+- `STACKLET_MCP_PLATFORM_ALLOW_MUTATIONS` (default: false) - Enable calling mutations in the Platform GraphQL API
+
+**File Storage:**
+Query results from AssetDB tools are automatically saved to the configured downloads directory:
+- Complete query results are saved as JSON files for analysis with other tools
+- Files use descriptive naming: `assetdb_{query_id}_{result_id}.json` (for saved queries) or `assetdb_{result_id}.json` (for ad-hoc queries)
+- The downloads directory is created automatically if it doesn't exist
+- Files persist after tool execution for further analysis
+
+**External Dependencies:**
+- Documentation files are fetched from the live Stacklet docs service at runtime
+- Redash endpoint is derived by replacing "api." with "redash." in the platform endpoint
+- Docs endpoint is derived by replacing "api." with "docs." in the platform endpoint
+
+## Known Issues & Design Notes
+
+When you're editing code which matches one of these concerns, think extra hard about
+the impact of your changes; prefer to mitigate these issues rather than further
+entrench them.
+
+**Documentation Service Dependency:** The docs client fetches documentation from a live Stacklet deployment's docs service (derived by replacing "api." with "docs." in the platform endpoint). This requires proper authentication and network access to the docs service.
+
+**AssetDB Data Source:** The AssetDB client defaults to `data_source_id=1` for the main AssetDB instance. This is hardcoded but can be overridden in function calls
+internally.
+
+**Authentication Complexity:** Requires three different credential fields (endpoint, access_token, identity_token) which must all be configured correctly for full functionality.
+
+**Test Coverage:** Most tests are end-to-end tool tests with mocked downstream HTTP
+interactions, which is an appropriate level of abstraction for most cases in this codebase. AssetDB in particular is lacking test coverage in some areas, but most tools are well tested, and the patterns seen in the existing tests should be repeated where possible.
+
+**Dict Returns:** Many tools and client methods should return better-structured data.
+
+**Loose Validation:** Tool parameters in particular could often benefit from further
+type annotation to encode (and advertise to clients!) expectations. Obvious examples include:
+- download_format literals
+- assetdb result timeout
+- query_id >= 1
+
+## Agent Configuration
+
+**MCP Client Configuration:**
+The server supports generating `.mcp.json` configuration files for Claude Desktop and other MCP clients:
+
+```bash
+# List available profiles
+just run agent-config list
+
+# Generate configuration for default profile (restricted)
+just run agent-config generate default
+
+# Generate configuration for unrestricted profile (all tools enabled)
+just run agent-config generate unrestricted
+```
+
+**Configuration Profiles:**
+- `default` - Safe profile with write operations disabled (assetdb_allow_save=false, assetdb_allow_archive=false, platform_allow_mutations=false)
+- `unrestricted` - Full access profile with all tools enabled
+
+## Important Advice
+
+- When running python in this project, always use "uv run python".
+- When you've made code changes, verify them with "just test" and "just lint".
+- Use `just install` to set up the development environment and generate `.mcp.json` automatically.
+- You will find it useful to have access to the Redash source code as you work; this
+  project talks to `https://github.com/stacklet/redash`, NOT the upstream project by
+  `getredash`. Cloning that repository into a temp directory and using the filesystem
+  is the most effective way to answer questions about redash implementation details.

stacklet_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: stacklet-mcp
+Version: 0.1.0
+Summary: MCP server for the Stacklet environment
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=2
+Requires-Dist: graphql-core>=3.2
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic-settings>=2.10.1
+Requires-Dist: pydantic>=2.11.7

stacklet_mcp-0.1.0/README.md

@@ -0,0 +1,115 @@
+# Stacklet MCP Server
+
+This is the MCP (Model Context Protocol) server for the Stacklet environment.
+It exposes toolsets for granting LLMs the powers of:
+
+* AssetDB SQL queries (ad-hoc and saved)
+* Platform GraphQL operations (and export of large datasets)
+* Documentation access (in .md, for context)
+
+Each of the toolsets has an "info" tool with useful context, available to any client which supports minimal MCP features.
+Asking your agent to tell you about a toolset is a fairly reliable way to get it to call the info tool and load up its context with relevant information.
+
+**WARNING**: most Stacklet installations contain confidential data; this server largely exists to feed that data to your agent's LLM, which is generally running in a datacenter _Somewhere_. Be very confident in your understanding of all relevant data security policies before running this server.
+
+**FURTHER WARNING**: when running with default settings, the worst an LLM can do with this server is make ill-advised queries, which is often regrettable but generally no worse than a well-intentioned human user might do.
+
+By enabling the `_ALLOW_` options documented below, you are granting an LLM free rein to do _anything_ you could do with Stacklet; doing so naturally bears risks proportional to your own level of access. Strongly consider authenticating as a custom Stacklet user with permissions tightly scoped to your task as an additional safeguard.
+
+
+## Installation
+
+The easiest way to get the `stacklet-mcp` binary is via `pip` or `uv`, with
+
+```
+pip install stacklet-mcp
+```
+
+or
+
+```
+uv tool install stacklet-mcp
+```
+
+Once installed, an agent configuration file (`.mcp.json`) can be generated with
+
+```
+stacklet-mcp agent-config generate $profile
+```
+
+where `$profile` can be either default (no edit allowed) or `unrestricted` (all edits allowed).
+The configuration can be manually tweaked to just allow some edits.
+
+
+## Authentication
+
+The MCP server needs to be authenticated wtih the Stacklet environment before use.
+The easiest way to authenticate to your Stacklet environment is to use the [stacklet-admin](https://pypi.org/project/stacklet.client.platform/) command, which is most easily installed with:
+
+```
+uv tool install stacklet.client.platform
+```
+
+Once you've configured that, a
+
+```
+stacklet-admin login
+```
+
+will grant the MCP server access as the authenticated user for twelve hours. Leaving aside the default blocks on saving queries and mutating platform, the server will have the same powers and restrictions as that user.
+
+
+## Server configuration
+
+The MCP server can be configured via environment variables.
+
+When the MCP is run from an agent, those can be set in the `"env"` section of the `.mcp.json` file.
+
+The following variables are available:
+
+- `STACKLET_MCP_DOWNLOADS_PATH`: directory for storing query result files (default: system temp directory)
+- `STACKLET_MCP_ASSETDB_DATASOURCE`: the datasource ID for AssetDB in Redash (default: `1`)
+- `STACKLET_MCP_ASSETDB_ALLOW_SAVE`: whether to enable write operations in AssetDB (default: `false`)
+- `STACKLET_MCP_ASSETDB_ALLOW_ARCHIVE`: whether to enable query archiving functionality in AssetDB (default: `false`)
+- `STACKLET_MCP_PLATFORM_ALLOW_MUTATIONS`: whether to enable executing mutations in Platform API (default: `false`)
+
+
+## Development
+
+For development, a few setup steps are required:
+
+
+1) install required tools. The easiest way is through [Mise](https://mise.jdx.dev/):
+
+```
+mise install
+```
+
+2) install dependencies via
+
+```
+just install
+```
+
+This will also create a default`.mcp.json` (so long as there's nothing there already) with default read-only settings, which enables convenient experimentation by running e.g. [Claude Code](https://claude.com/product/claude-code)) in the project root without risk of altering saved AssetDB queries or running Platform mutations.
+
+For alternative integrations, the `.mcp.json` file should serve as a starting point, but the details may vary by context; the best documentation for the format itself seems to be [here](https://gofastmcp.com/integrations/mcp-json-configuration#mcp-json-configuration-standard).
+
+
+3) Authenticate to the deployment as described above.
+
+4) Run the MCP server with
+
+```
+just run [options...]
+```
+
+
+### Inspect MCP protocol
+
+
+The MCP Protocol Inspector is invaluable for peeking at the details of the protocol in use. It can be run via
+
+```
+just inspect
+```

stacklet_mcp-0.1.0/justfile

@@ -0,0 +1,42 @@
+# Setup development environment
+install:
+    #!/usr/bin/env bash
+    set -e
+
+    uv sync
+    if [ ! -e .mcp.json ]; then
+      just agent-config
+      echo "Wrote .mcp.json"
+    fi
+
+# Run the MCP server locally
+run *args:
+    uv run stacklet-mcp {{args}}
+
+# Run code formatters/linters
+lint:
+    uv run pre-commit run --all-files
+
+# Run tests
+test *args:
+    uv run pytest {{args}}
+
+# Run tests with coverage
+test-coverage *args:
+    just test --cov {{args}}
+
+# Run mcp-inspector
+inspect:
+    npx @modelcontextprotocol/inspector just run
+
+# Generate agent configuration (.mcp.json)
+agent-config profile="default":
+    just run agent-config generate {{profile}} > .mcp.json
+
+# Tag current commit with a release tag based on the project version
+tag-release:
+    #!/usr/bin/env bash
+    set -e
+
+    version="$(uv run python -c 'from stacklet.mcp import __version__; print(__version__)')"
+    git tag -a "v$version" -m "Version $version"

stacklet_mcp-0.1.0/license-header.tpl

@@ -0,0 +1 @@
+Copyright (c) $create_year$year_delimiter$edit_year Stacklet, Inc.

stacklet_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+build-backend = "hatchling.build"
+
+requires = [ "hatchling" ]
+
+[project]
+name = "stacklet-mcp"
+description = "MCP server for the Stacklet environment"
+requires-python = ">=3.12"
+classifiers = [
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+dynamic = [ "version" ]
+
+dependencies = [
+  "fastmcp>=2",
+  "graphql-core>=3.2",
+  "httpx>=0.28.1",
+  "pydantic>=2.11.7",
+  "pydantic-settings>=2.10.1",
+]
+scripts.stacklet-mcp = "stacklet.mcp.mcp:main"
+
+[dependency-groups]
+dev = [
+  "add-license-header>=2.4",
+  "mypy>=1.8",
+  "pre-commit>=4.2",
+  "pyproject-fmt>=2.6",
+  "pytest>=7",
+  "pytest-asyncio>=0.21",
+  "pytest-cov>=7",
+  "ruff>=0.12",
+]
+
+[tool.hatch.version]
+path = "stacklet/mcp/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = [ "stacklet" ]
+
+[tool.ruff]
+line-length = 100
+
+# Add `line-too-long` and isort to the enforced rule set.
+lint.extend-select = [ "E501", "I" ]
+lint.isort.lines-after-imports = 2
+# Use a single line between direct and from import.
+lint.isort.lines-between-types = 1
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+addopts = "--no-cov-on-fail"
+
+[tool.coverage.report]
+fail_under = 94.0
+show_missing = true
+skip_covered = true
+
+[tool.mypy]
+strict = true
+install_types = true
+warn_return_any = true
+warn_unused_configs = true
+check_untyped_defs = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+ignore_missing_imports = true
+non_interactive = true
+exclude = [ "tests/" ]
+plugins = [ "pydantic.mypy" ]

stacklet_mcp-0.1.0/stacklet/mcp/__init__.py

@@ -0,0 +1,8 @@
+# LICENSE HEADER MANAGED BY add-license-header
+#
+# Copyright (c) 2025 Stacklet, Inc.
+#
+
+"""Stacklet MCP server."""
+
+__version__ = "0.1.0"

stacklet_mcp-0.1.0/stacklet/mcp/__main__.py

@@ -0,0 +1,11 @@
+# LICENSE HEADER MANAGED BY add-license-header
+#
+# Copyright (c) 2025 Stacklet, Inc.
+#
+
+"""Entry point for running the server from the package."""
+
+from .mcp import main
+
+
+main()

stacklet_mcp-0.1.0/stacklet/mcp/assetdb/__init__.py

@@ -0,0 +1,4 @@
+# LICENSE HEADER MANAGED BY add-license-header
+#
+# Copyright (c) 2025 Stacklet, Inc.
+#