komodo-mcp-server 1.2.0

package/CHANGELOG.md

@@ -0,0 +1,187 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+--------------------------------------------------------------
+
+## [1.2.0] - Major Architecture Overhaul
+
+This release introduces a complete internal restructuring of the codebase for better maintainability, 
+performance, and extensibility. The external API remains backwards compatible.
+
+### ✨ Highlights
+
+- **Clean Architecture**: Complete separation of framework (`server/`) and application (`app/`) layers
+- **New Server Builder Pattern**: Declarative, fluent API for MCP server construction
+- **OpenTelemetry Support**: Optional distributed tracing and metrics collection
+- **Dynamic Tool Availability**: Tools are now enabled/disabled based on Komodo connection status
+- **Improved Container Health Checks**: Smart readiness probes for better orchestration
+- **Legacy SSE Support**: Optional backwards compatibility for older MCP clients
+
+### 🔐 Security
+- **Docker Image Signing**: All images are now signed using Sigstore/Cosign keyless signing
+- **Build Attestation**: SLSA provenance is attached to all Docker images
+- **SBOM Generation**: Software Bill of Materials included with every release
+- **CORS Protection**: Wildcard origins blocked in production mode
+- **Rate Limiting**: Configurable request limits (default: 1000/15min)
+- **Session Limits**: Prevent memory exhaustion attacks
+
+### 🚀 New Features
+
+#### MCP Registry & npm Publishing
+- **MCP Registry Publishing**: New workflow to publish to the official MCP Registry (`io.github.mp-tool/komodo-mcp-server`)
+- **server.json**: Added MCP Registry metadata file for discoverability
+- **npm Publishing**: New workflow for npm registry releases
+- **Production Build**: Optimized builds without source maps for npm releases
+
+#### Server Builder Pattern
+Build MCP servers with a clean, declarative API:
+```typescript
+const server = new McpServerBuilder<KomodoClient>()
+  .withOptions(serverOptions)
+  .withToolProvider(toolAdapter)
+  .build();
+```
+
+#### Dynamic Tool Availability
+- Tools requiring Komodo connection are disabled until connected
+- `komodo_configure` is always available
+- MCP clients automatically receive updated tool lists
+
+#### OpenTelemetry Observability
+- Enable with `OTEL_ENABLED=true`
+- Automatic tracing for all API calls and tool executions
+- Metrics collection for request counts, durations, and errors
+- Compatible with Jaeger, Zipkin, and Datadog (not Tested)
+
+#### Improved Health & Readiness Probes
+- `/health` - Liveness probe (always 200 if server is running)
+- `/ready` - Smart readiness with accurate status codes:
+  - `200` - Ready to accept traffic
+  - `503` - Komodo configured but not connected
+  - `429` - Session limits reached
+
+#### Legacy SSE Transport
+- Enable with `MCP_LEGACY_SSE_ENABLED=true`
+- Supports older MCP clients using protocol 2024-11-05
+- Both modern Streamable HTTP and legacy SSE can run simultaneously
+
+### 🔧 Improvements
+
+#### CI/CD Pipeline
+- **Release Workflow**: Enhanced with image signing, build attestation, and improved release notes
+- **Pre-release Support**: Versions with hyphen (e.g., `1.2.0-beta.1`) are now marked as pre-releases
+- **Job Timeouts**: All CI jobs now have explicit timeouts for reliability
+- **Dependabot**: Automated dependency updates for npm, GitHub Actions, and Docker
+- **OSV Scanner**: New vulnerability scanning workflow for known CVEs
+
+#### Performance
+- **Faster Logging**: Pre-compiled regex patterns (~50-80% faster under load)
+- **Cached Tool Registry**: Eliminates repeated array allocations
+- **Efficient History Tracking**: O(1) circular buffer for connection state
+
+#### Developer Experience
+- **Structured Logging**: ECS-compatible JSON format for log aggregation
+- **Request Cancellation**: Full AbortSignal support through all layers
+- **Better Error Messages**: User-friendly recovery hints in error responses
+
+### 📦 Configuration
+
+New environment variables:
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `OTEL_ENABLED` | Enable OpenTelemetry tracing | `false` |
+| `MCP_LEGACY_SSE_ENABLED` | Enable legacy SSE transport | `false` |
+| `SESSION_MAX_COUNT` | Max Streamable HTTP sessions | `100` |
+| `LEGACY_SSE_MAX_SESSIONS` | Max legacy SSE sessions | `50` |
+
+### 🔄 Migration Notes
+
+This release is **backwards compatible**. No changes required for existing deployments.
+
+Internal changes (for contributors):
+- Source code reorganized: `src/app/` for Komodo-specific code, `src/server/` for reusable framework
+- API client moved from `src/api/` to `src/app/api/`
+- Configuration split into `src/app/config/` and `src/server/config/`
+- Error system moved to `src/server/errors/`
+
+--------------------------------------------------------------
+
+## [1.1.0] - Feature Parity Release
+
+### 🚀 New Tools
+- **Container Logs**: `komodo_get_container_logs`, `komodo_search_logs`
+- **Deployment Lifecycle**: pull, start, stop, restart, pause, unpause, destroy
+- **Stack Lifecycle**: pull, start, stop, restart, pause, unpause, destroy
+
+### 🔧 Improvements
+- Modernized transport layer using native MCP SDK
+- Improved type safety across all 44 tools
+- Better AI-agent-friendly tool descriptions
+- Centralized schema system for consistent validation
+
+--------------------------------------------------------------
+
+## [1.0.7] - Security & Auth
+
+### 🔒 Security
+- Added `helmet` middleware for HTTP security headers
+- API Key authentication support (`KOMODO_API_KEY`, `KOMODO_API_SECRET`)
+
+### 📖 Documentation
+- Comprehensive JSDoc documentation for all public APIs
+
+--------------------------------------------------------------
+
+## [1.0.6] - Advanced Logging
+
+### 📝 Logging System
+- Structured logging with configurable levels
+- Automatic sensitive data redaction
+- JWT and Bearer token scrubbing
+- Log injection prevention (CWE-117)
+- File logging support (`LOG_DIR`)
+- JSON format support (`LOG_FORMAT=json`)
+
+--------------------------------------------------------------
+
+## [1.0.5] - Security Hardening
+
+### 🔒 Security
+- CodeQL and OpenSSF Scorecard workflows
+- Automated dependency review
+- DNS rebinding protection
+- Rate limiting for MCP endpoints
+- Protocol version validation
+
+### 🔄 Transport
+- Migrated to Streamable HTTP Transport (MCP Spec 2025-06-18)
+- Active heartbeat mechanism
+- Session resilience with fault tolerance
+
+--------------------------------------------------------------
+
+## [1.0.4] - Architecture Refactoring
+
+### 🏗️ Architecture
+- Refactored from monolithic to modular design
+- Updated to latest `@modelcontextprotocol/sdk`
+- Added Zod schemas for input validation
+- Dynamic tool registry system
+
+--------------------------------------------------------------
+
+## [1.0.0] - Initial Release
+
+First public release of Komodo MCP Server.
+
+### Features
+- Docker container management (start, stop, restart, pause, unpause)
+- Server management and monitoring
+- Stack management for Docker Compose
+- Deployment management
+- Dual transport support (Stdio and HTTP)

package/LICENSE

@@ -0,0 +1,29 @@
+GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2025 Marcel Pfennig
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+---
+
+Komodo MCP Server - Model Context Protocol Server for Komodo Container Manager
+Author: Marcel Pfennig
+Repository: https://github.com/MP-Tool/komodo-mcp-server
+
+This project enables AI assistants to interact with Docker containers, 
+deployments, stacks, and servers managed by Komodo through the Model Context Protocol.
+
+For the full GPL-3.0 license text, visit:
+https://www.gnu.org/licenses/gpl-3.0.en.html

package/README.md

@@ -0,0 +1,214 @@
+<div align="center">
+
+# 🦎 Komodo MCP Server
+
+**Model Context Protocol Server for [Komodo](https://github.com/moghtech/komodo)**
+
+Manage your Docker or Podman deployments through Komodo with AI assistants and automation tools.
+
+Komodo MCP Server enables seamless interaction between AI assistants (like Claude, GitHub Copilot) and Komodo (Container Management Platform) for efficient container management, server orchestration, and deployment operations. The MCP-Server gives you the ability to control your Komodo-managed infrastructure by using natural language or automated workflows.
+
+[![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-blue.svg)](LICENSE) [![GitHub Release](https://img.shields.io/github/v/release/MP-Tool/komodo-mcp-server?logo=github)](https://github.com/MP-Tool/komodo-mcp-server/releases) [![Docker](https://img.shields.io/badge/Docker-Ready-2496ED?logo=docker&logoColor=white)](https://github.com/MP-Tool/komodo-mcp-server/pkgs/container/komodo-mcp-server) [![MCP](https://img.shields.io/badge/MCP-Compatible-green)](https://modelcontextprotocol.io)
+
+[![Build Status](https://github.com/MP-Tool/komodo-mcp-server/actions/workflows/release.yml/badge.svg)](https://github.com/MP-Tool/komodo-mcp-server/actions/workflows/release.yml) [![CodeQL](https://github.com/MP-Tool/komodo-mcp-server/actions/workflows/codeql.yml/badge.svg)](https://github.com/MP-Tool/komodo-mcp-server/actions/workflows/codeql.yml) [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/MP-Tool/komodo-mcp-server/badge)](https://securityscorecards.dev/viewer/?uri=github.com/MP-Tool/komodo-mcp-server) [![GitHub Issues](https://img.shields.io/github/issues/MP-Tool/komodo-mcp-server?logo=github)](https://github.com/MP-Tool/komodo-mcp-server/issues)
+
+[Features](#features) • [Quick Start](#quick-start) • [Examples](#examples) • [Documentation](#documentation)
+
+</div>
+
+---
+
+## Features
+
+<table>
+<tr>
+<td width="50%">
+
+### 🐳 Container Management
+- Start, stop, restart containers
+- Pause and unpause operations  
+- List and monitor containers
+- Cross-server management
+
+</td>
+<td width="50%">
+
+### 📦 Deployment & Stacks
+- Deploy containers and updates
+- Manage Docker Compose stacks
+- Multi-environment deployments
+- Stack lifecycle control
+
+</td>
+</tr>
+<tr>
+<td width="50%">
+
+### 🖥️ Server Operations
+- List all managed servers
+- Get server statistics
+- Health monitoring
+- Resource tracking
+
+</td>
+<td width="50%">
+
+### 🤖 MCP Integration
+- Works with any MCP client
+- Claude Desktop ready
+- VS Code Copilot support
+- n8n automation compatible
+- Dual Transport (Stdio + HTTP/SSE)
+
+</td>
+</tr>
+<tr>
+<td width="50%">
+
+### ⚡ Performance
+- Pre-compiled regex for logging
+- Tool registry caching
+- O(1) circular buffer history
+- Request cancellation support
+
+</td>
+<td width="50%">
+
+### 🔒 Security & Reliability
+- DNS rebinding protection
+- Rate limiting (configurable)
+- CORS origin validation
+- Graceful shutdown handling
+
+</td>
+</tr>
+</table>
+
+## Quick Start
+
+### Option 1: Docker (Recommended)
+
+```bash
+# Pull the image
+docker pull ghcr.io/mp-tool/komodo-mcp-server:latest
+
+# Run with Docker Compose
+cd examples/compose
+cp .env.example .env
+# Edit .env with your Komodo credentials
+docker compose up -d
+```
+
+### Option 2: Claude Desktop
+
+```bash
+# Copy config
+cp examples/claude/claude_desktop_config.json \
+   ~/Library/Application\ Support/Claude/claude_desktop_config.json
+
+# Edit credentials and restart Claude
+```
+
+### Option 3: VS Code
+
+```bash
+# Global integration
+mkdir -p ~/.vscode/mcp
+cp examples/vscode/mcp.json ~/.vscode/mcp/
+
+# Edit credentials and reload VS Code
+```
+
+> **📚 Full setup guides:** See [`examples/`](examples/) for detailed instructions
+
+## Examples
+
+### 💬 With AI Assistants
+
+Ask Claude, Copilot, or any MCP-compatible assistant:
+
+```
+"List all my Komodo servers"
+"Show containers on production-server"  
+"Start the nginx container"
+"Deploy my-app to staging"
+"Get stats for dev-server"
+```
+
+### 🔄 With n8n Automation
+
+Comming soon: Pre-built n8n workflows for automated container health checks and deployment pipelines.
+
+## Documentation
+
+### Requirements
+- **Komodo** v1.19.5 or later
+- **Docker** (for containerized deployment)
+- **Node.js 20+** (for local development)
+- **Valid Komodo credentials** (API Key/Secret or username/password)
+
+### Integration Guides
+- **[Claude Desktop](examples/claude/)** - Direct MCP integration
+- **[VS Code](examples/vscode/)** - GitHub Copilot Chat support  
+- **[Docker Compose](examples/compose/)** - Standalone deployment
+- **[Docker Desktop](examples/docker-desktop/)** - Native MCP beta feature
+
+### Observability (OpenTelemetry)
+
+Enable distributed tracing and metrics with OpenTelemetry:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `OTEL_ENABLED` | `false` | Enable OpenTelemetry |
+| `OTEL_SERVICE_NAME` | `mcp-server` | Service name for traces |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | - | OTLP endpoint (e.g., Jaeger, Grafana) |
+| `OTEL_DEBUG` | `false` | Enable debug logging |
+
+
+## License
+GPL-3.0 License - see [LICENSE](LICENSE) for details.
+
+## Contributing
+Contributions are welcome! See our [Contributing Guide](CONTRIBUTING.md) for details.
+
+- 🐛 [Report bugs](https://github.com/MP-Tool/komodo-mcp-server/issues)
+- 💡 [Request features](https://github.com/MP-Tool/komodo-mcp-server/issues)
+- 🔧 [Submit PRs](https://github.com/MP-Tool/komodo-mcp-server/pulls)
+
+### Development
+
+```bash
+# Clone and install
+git clone https://github.com/MP-Tool/komodo-mcp-server.git
+cd komodo-mcp-server
+npm install
+
+# Build and run
+npm run build
+npm start
+```
+
+## Security
+Report security vulnerabilities via GitHub's Private Vulnerability Reporting (see [SECURITY.md](SECURITY.md)).
+
+**Best practices:**
+- Never commit credentials
+- Use environment variables
+- Keep dependencies updated
+- Run as non-root user (default in Docker)
+
+## Links
+
+- **[Komodo GitHub](https://github.com/moghtech/komodo)** - Container orchestration platform
+- **[Komodo Docs](https://komo.do/docs)** - Komodo documentation
+- **[Model Context Protocol](https://modelcontextprotocol.io)** - MCP specification
+- **[Examples & Integrations](examples/)** - Ready-to-use configurations
+
+---
+
+<div align="center">
+
+**Built with ❤️ for the Komodo  community 🦎**
+[Report Bug](https://github.com/MP-Tool/komodo-mcp-server/issues) • [Request Feature](https://github.com/MP-Tool/komodo-mcp-server/issues) • [Discussions](https://github.com/MP-Tool/komodo-mcp-server/discussions)
+
+</div>

package/build/app/adapters.d.ts

@@ -0,0 +1,20 @@
+import type { KomodoClient } from './api/index.js';
+import type { IToolProvider, IToolDefinition, IResourceProvider, IResourceDefinition, IResourceTemplateDefinition, IPromptProvider, IPromptDefinition } from './framework.js';
+declare class ToolRegistryAdapter implements IToolProvider<KomodoClient> {
+    getTools(): ReadonlyArray<IToolDefinition<unknown, KomodoClient>>;
+    getAvailableTools(): ReadonlyArray<IToolDefinition<unknown, KomodoClient>>;
+    setConnectionState(connected: boolean): void;
+}
+export declare const toolRegistryAdapter: ToolRegistryAdapter;
+declare class ResourceRegistryAdapter implements IResourceProvider {
+    getResources(): ReadonlyArray<IResourceDefinition>;
+    getTemplates(): ReadonlyArray<IResourceTemplateDefinition>;
+    hasResources(): boolean;
+}
+export declare const resourceRegistryAdapter: ResourceRegistryAdapter;
+declare class PromptRegistryAdapter implements IPromptProvider {
+    getPrompts(): ReadonlyArray<IPromptDefinition>;
+    hasPrompts(): boolean;
+}
+export declare const promptRegistryAdapter: PromptRegistryAdapter;
+export {};

package/build/app/adapters.js

@@ -0,0 +1,36 @@
+import { toolRegistry } from './mcp/tools/index.js';
+import { resourceRegistry } from './mcp/resources/index.js';
+import { promptRegistry } from './mcp/prompts/index.js';
+class ToolRegistryAdapter {
+    getTools() {
+        return toolRegistry.getTools();
+    }
+    getAvailableTools() {
+        return toolRegistry.getAvailableTools();
+    }
+    setConnectionState(connected) {
+        toolRegistry.setConnectionState(connected);
+    }
+}
+export const toolRegistryAdapter = new ToolRegistryAdapter();
+class ResourceRegistryAdapter {
+    getResources() {
+        return resourceRegistry.getResources();
+    }
+    getTemplates() {
+        return resourceRegistry.getTemplates();
+    }
+    hasResources() {
+        return resourceRegistry.hasResources();
+    }
+}
+export const resourceRegistryAdapter = new ResourceRegistryAdapter();
+class PromptRegistryAdapter {
+    getPrompts() {
+        return promptRegistry.getPrompts();
+    }
+    hasPrompts() {
+        return promptRegistry.hasPrompts();
+    }
+}
+export const promptRegistryAdapter = new PromptRegistryAdapter();

package/build/app/api/base.d.ts

@@ -0,0 +1,43 @@
+import { KomodoClient as CoreClient } from 'komodo_client';
+export type OperationType = 'list' | 'get' | 'create' | 'update' | 'delete' | 'action' | 'logs';
+export declare const OPERATION_TIMEOUTS: Record<OperationType, number>;
+export interface ApiOperationOptions {
+    signal?: AbortSignal;
+    operationType?: OperationType;
+    timeout?: number;
+}
+export declare const RETRYABLE_NETWORK_ERROR_CODES: readonly ["ECONNREFUSED", "ETIMEDOUT", "ECONNRESET", "ENOTFOUND", "ENETUNREACH", "EHOSTUNREACH", "EPIPE", "EAI_AGAIN"];
+export interface ErrorWithCode extends Error {
+    code?: string;
+}
+export interface ErrorWithStatus extends Error {
+    status?: number;
+    response?: {
+        status?: number;
+    };
+}
+export declare function isErrorWithCode(error: unknown): error is ErrorWithCode;
+export declare function isErrorWithStatus(error: unknown): error is ErrorWithStatus;
+export declare function getErrorStatusCode(error: unknown): number | undefined;
+export interface RetryConfig {
+    maxRetries: number;
+    baseDelayMs: number;
+    exponentialBackoff: boolean;
+    retryableStatusCodes: number[];
+    jitterFactor: number;
+}
+export declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+type ValidationFunction = (value: string) => void;
+export declare abstract class BaseResource {
+    protected client: ReturnType<typeof CoreClient>;
+    protected logger: import("../framework.js").Logger;
+    constructor(client: ReturnType<typeof CoreClient>);
+    protected checkAborted(signal?: AbortSignal): void;
+    protected withValidation(value: string, validator: ValidationFunction, options?: ApiOperationOptions): void;
+    protected getTimeout(options?: ApiOperationOptions, defaultType?: OperationType): number;
+    protected withRetry<T>(operation: () => Promise<T>, config?: Partial<RetryConfig>, operationName?: string): Promise<T>;
+    private isRetryableError;
+    private calculateRetryDelay;
+    private sleep;
+}
+export {};

package/build/app/api/base.js

@@ -0,0 +1,108 @@
+import { logger as baseLogger } from '../framework.js';
+export const OPERATION_TIMEOUTS = {
+    list: 10_000,
+    get: 10_000,
+    create: 30_000,
+    update: 30_000,
+    delete: 30_000,
+    action: 300_000,
+    logs: 60_000,
+};
+export const RETRYABLE_NETWORK_ERROR_CODES = [
+    'ECONNREFUSED',
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'ENOTFOUND',
+    'ENETUNREACH',
+    'EHOSTUNREACH',
+    'EPIPE',
+    'EAI_AGAIN',
+];
+export function isErrorWithCode(error) {
+    return error instanceof Error && 'code' in error && typeof error.code === 'string';
+}
+export function isErrorWithStatus(error) {
+    if (!(error instanceof Error))
+        return false;
+    const err = error;
+    return typeof err.status === 'number' || typeof err.response?.status === 'number';
+}
+export function getErrorStatusCode(error) {
+    if (!isErrorWithStatus(error))
+        return undefined;
+    return error.status ?? error.response?.status;
+}
+export const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    exponentialBackoff: true,
+    retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+    jitterFactor: 0.2,
+};
+export class BaseResource {
+    client;
+    logger;
+    constructor(client) {
+        this.client = client;
+        this.logger = baseLogger.child({ component: this.constructor.name });
+    }
+    checkAborted(signal) {
+        if (signal?.aborted) {
+            const error = new Error('Operation cancelled');
+            error.name = 'AbortError';
+            throw error;
+        }
+    }
+    withValidation(value, validator, options) {
+        validator(value);
+        this.checkAborted(options?.signal);
+    }
+    getTimeout(options, defaultType = 'get') {
+        if (options?.timeout) {
+            return options.timeout;
+        }
+        return OPERATION_TIMEOUTS[options?.operationType ?? defaultType];
+    }
+    async withRetry(operation, config = {}, operationName) {
+        const retryConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+        let lastError;
+        for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                const isRetryable = this.isRetryableError(error, retryConfig.retryableStatusCodes);
+                if (!isRetryable || attempt >= retryConfig.maxRetries) {
+                    throw error;
+                }
+                const delay = this.calculateRetryDelay(attempt, retryConfig);
+                this.logger.warn(`${operationName ?? 'Operation'} failed (attempt ${attempt + 1}/${retryConfig.maxRetries + 1}), ` +
+                    `retrying in ${delay}ms: ${error.message}`);
+                await this.sleep(delay);
+            }
+        }
+        throw lastError ?? new Error('Retry failed');
+    }
+    isRetryableError(error, retryableStatusCodes) {
+        if (isErrorWithCode(error)) {
+            const errorCode = error.code;
+            if (errorCode && RETRYABLE_NETWORK_ERROR_CODES.includes(errorCode)) {
+                return true;
+            }
+        }
+        const statusCode = getErrorStatusCode(error);
+        if (statusCode !== undefined && retryableStatusCodes.includes(statusCode)) {
+            return true;
+        }
+        return false;
+    }
+    calculateRetryDelay(attempt, config) {
+        const baseDelay = config.exponentialBackoff ? config.baseDelayMs * Math.pow(2, attempt) : config.baseDelayMs;
+        const jitter = baseDelay * config.jitterFactor * Math.random();
+        return Math.floor(baseDelay + jitter);
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

package/build/app/api/client.d.ts

@@ -0,0 +1,17 @@
+import { type IApiClient } from '../framework.js';
+import { HealthCheckResult } from './types.js';
+import { ServerResource, ContainerResource, StackResource, DeploymentResource } from './resources/index.js';
+export declare class KomodoClient implements IApiClient {
+    readonly clientType: "komodo";
+    private client;
+    private baseUrl;
+    readonly servers: ServerResource;
+    readonly containers: ContainerResource;
+    readonly stacks: StackResource;
+    readonly deployments: DeploymentResource;
+    private constructor();
+    getBaseUrl(): string;
+    static login(baseUrl: string, username: string, password: string, timeoutMs?: number): Promise<KomodoClient>;
+    static connectWithApiKey(baseUrl: string, key: string, secret: string): KomodoClient;
+    healthCheck(): Promise<HealthCheckResult>;
+}