@mks2508/coolify-mks-cli-mcp 0.4.3 → 0.6.0

package/src/index.ts

@@ -1,874 +1,88 @@
 /**
- * Coolify MCP Server - Entry point.
+ * @mks2508/coolify-mks-cli-mcp — SDK, CLI, and MCP server for Coolify.
  *
- * Exports the MCP server with 21 tools for Coolify management.
+ * Use as a library (SDK):
+ * ```typescript
+ * import { Coolify } from '@mks2508/coolify-mks-cli-mcp'
+ *
+ * const coolify = new Coolify({ url: 'https://coolify.example.com', token: '...' })
+ * const apps = await coolify.applications.list()
+ * const app = await coolify.applications.resolve('my-app')
+ * await coolify.applications.deploy(app.uuid)
+ * ```
+ *
+ * Use as MCP server:
+ * ```bash
+ * coolify-mcp-server  # stdio transport
+ * ```
+ *
+ * Use as CLI:
+ * ```bash
+ * coolify-mcp list
+ * coolify-mcp deploy
+ * coolify-mcp logs
+ * ```
  *
  * @module
  */
 
-import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
-import { z } from 'zod'
-import { isOk, isErr } from '@mks2508/no-throw'
-import { getCoolifyService } from './coolify/index.js'
-
-// Create service instance
-const coolify = getCoolifyService()
-
-/**
- * Coolify MCP Server with 21 tools for deployment management.
- */
-export const coolifyServer = createSdkMcpServer({
-  name: 'coolify-mks-cli',
-  version: '0.1.0',
-  tools: [
-    // 1. deploy
-    tool(
-      'deploy',
-      `Deploy or redeploy an application to Coolify.
-
-Triggers a new deployment for the specified application UUID.
-Can force rebuild without cache if needed.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID in Coolify'),
-        force: z.boolean().default(false).describe('Force rebuild without cache'),
-        tag: z.string().optional().describe('Deploy specific tag/version'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.deploy({ uuid: args.uuid, force: args.force, tag: args.tag })
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({
-                success: true,
-                deploymentUuid: result.value.deploymentUuid,
-                resourceUuid: result.value.resourceUuid,
-                message: 'Deployment started',
-              }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Deployment failed: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 2. get_env_vars
-    tool(
-      'get_env_vars',
-      `Get environment variables for a Coolify application.
-
-Returns all environment variables with metadata including whether
-they are runtime or buildtime, and if they are required.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.getEnvironmentVariables(args.uuid)
-
-        if (isOk(result)) {
-          const runtimeVars = result.value.filter(ev => ev.is_runtime)
-          const buildtimeVars = result.value.filter(ev => ev.is_buildtime)
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({
-                success: true,
-                total: result.value.length,
-                runtimeCount: runtimeVars.length,
-                buildtimeCount: buildtimeVars.length,
-                runtime: runtimeVars,
-                buildtime: buildtimeVars,
-              }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to get env vars: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 3. set_env_vars
-    tool(
-      'set_env_vars',
-      `Set environment variables for a Coolify application.
-
-Updates or adds environment variables. Existing vars not in the
-input are preserved. Redeploy after setting to apply changes.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID'),
-        envVars: z.record(z.string()).describe('Key-value pairs of environment variables'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.setEnvironmentVariables(args.uuid, args.envVars)
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: `Set ${Object.keys(args.envVars).length} environment variable(s). Use deploy tool to apply changes.`,
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to set env vars: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 4. get_deployment_status
-    tool(
-      'get_deployment_status',
-      `Get the current status of a Coolify application.
-
-Returns deployment state, health status, and resource usage.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.getApplicationStatus(args.uuid)
-
-        if (isOk(result)) {
-          return {
-            content: [{ type: 'text' as const, text: JSON.stringify({ status: result.value }, null, 2) }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to get status: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 4. list_applications
-    tool(
-      'list_applications',
-      `List all applications in Coolify.
-
-Optionally filter by team or project ID.`,
-      {
-        teamId: z.string().optional().describe('Filter by Team ID'),
-        projectId: z.string().optional().describe('Filter by Project ID'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.listApplications(args.teamId, args.projectId)
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, count: result.value.length, applications: result.value }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to list applications: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 5. delete_application
-    tool(
-      'delete_application',
-      `Delete an application from Coolify.
-
-WARNING: This action is irreversible. All deployments, environment
-variables, domains, and history will be permanently deleted.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID to delete'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.deleteApplication(args.uuid)
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, message: `Application ${args.uuid} deleted successfully` }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to delete application: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 6. get_application_logs
-    tool(
-      'get_application_logs',
-      `Get logs for a Coolify application.
-
-Retrieve recent logs with optional tail limit.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID'),
-        tail: z.number().optional().describe('Number of log lines to retrieve'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.getApplicationLogs(args.uuid, { tail: args.tail })
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({
-                success: true,
-                timestamp: result.value.timestamp,
-                logCount: result.value.logs.length,
-                logs: result.value.logs,
-              }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to get logs: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 7. start_application
-    tool(
-      'start_application',
-      `Start a stopped Coolify application.
-
-Use this to start applications that were previously stopped.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID to start'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.startApplication(args.uuid)
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, message: `Application ${args.uuid} started`, application: result.value }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to start application: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 8. stop_application
-    tool(
-      'stop_application',
-      `Stop a running Coolify application.
-
-WARNING: This will make the application temporarily unavailable.
-Containers will be stopped but not deleted.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID to stop'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.stopApplication(args.uuid)
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, message: `Application ${args.uuid} stopped`, application: result.value }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to stop application: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 9. restart_application
-    tool(
-      'restart_application',
-      `Restart a Coolify application.
-
-Equivalent to stopping and then starting the application.
-Useful to apply configuration changes or recover from errors.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID to restart'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.restartApplication(args.uuid)
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, message: `Application ${args.uuid} restarted`, application: result.value }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to restart application: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 10. get_deployment_history
-    tool(
-      'get_deployment_history',
-      `Get deployment history for a Coolify application.
-
-Returns list of all deployments with status, timestamps, and commit info.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.getApplicationDeploymentHistory(args.uuid)
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, count: result.value.length, deployments: result.value }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to get deployment history: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 11. update_application
-    tool(
-      'update_application',
-      `Update configuration for a Coolify application.
-
-Can modify name, description, build settings, and commands.
-Redeploy after updating to apply changes.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID'),
-        name: z.string().optional().describe('New application name'),
-        description: z.string().optional().describe('New description'),
-        buildPack: z.enum(['dockerfile', 'nixpacks', 'static', 'dockercompose']).optional().describe('Build pack type'),
-        gitBranch: z.string().optional().describe('Git branch to deploy'),
-        portsExposes: z.string().optional().describe('Ports to expose (comma-separated)'),
-        installCommand: z.string().optional().describe('Install command (nixpacks)'),
-        buildCommand: z.string().optional().describe('Build command'),
-        startCommand: z.string().optional().describe('Start command'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.updateApplication(args.uuid, {
-          name: args.name,
-          description: args.description,
-          buildPack: args.buildPack,
-          gitBranch: args.gitBranch,
-          portsExposes: args.portsExposes,
-          installCommand: args.installCommand,
-          buildCommand: args.buildCommand,
-          startCommand: args.startCommand,
-        })
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({
-                success: true,
-                message: `Application ${args.uuid} updated. Use deploy tool to apply changes.`,
-                application: result.value,
-              }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to update application: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 12. list_servers
-    tool(
-      'list_servers',
-      `List all available servers in Coolify.
-
-Returns server UUIDs, names, and IPs. Use server UUID when creating applications.`,
-      {},
-      async () => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.listServers()
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, count: result.value.length, servers: result.value }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to list servers: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 13. get_server
-    tool(
-      'get_server',
-      `Get details of a specific Coolify server.
-
-Returns server information including name, IP, status, and configuration.`,
-      {
-        serverUuid: z.string().uuid().describe('Server UUID to get details for'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.getServer(args.serverUuid)
-
-        if (isOk(result)) {
-          return {
-            content: [{ type: 'text' as const, text: JSON.stringify({ success: true, server: result.value }, null, 2) }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to get server: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 14. list_projects
-    tool(
-      'list_projects',
-      `List all projects in Coolify.
-
-Returns project UUIDs, names, and associated environments.`,
-      {},
-      async () => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.listProjects()
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, count: result.value.length, projects: result.value }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to list projects: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 15. list_teams
-    tool(
-      'list_teams',
-      `List all teams in Coolify.
-
-Returns team IDs, names, and configuration.`,
-      {},
-      async () => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.listTeams()
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, count: result.value.length, teams: result.value }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to list teams: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 16. get_server_destinations
-    tool(
-      'get_server_destinations',
-      `Get available destinations for a Coolify server.
-
-Returns destination UUIDs needed when creating applications.
-Each destination represents a Docker network/environment on the server.`,
-      {
-        serverUuid: z.string().uuid().describe('Server UUID to get destinations for'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.getServerDestinations(args.serverUuid)
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({
-                success: true,
-                serverUuid: args.serverUuid,
-                count: result.value.length,
-                destinations: result.value,
-              }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to get destinations: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 17. create_application
-    tool(
-      'create_application',
-      `Create a new application in Coolify from a GitHub repository.
-
-Requires server UUID, project UUID, and environment UUID.
-The GitHub repository must be accessible via the configured GitHub App.`,
-      {
-        name: z.string().describe('Application name'),
-        serverUuid: z.string().uuid().describe('Server UUID to deploy to'),
-        projectUuid: z.string().uuid().describe('Project UUID'),
-        environmentUuid: z.string().uuid().describe('Environment UUID'),
-        githubRepoUrl: z.string().describe('GitHub repository URL (e.g., https://github.com/user/repo)'),
-        description: z.string().optional().describe('Application description'),
-        branch: z.string().default('main').describe('Git branch to deploy'),
-        buildPack: z.enum(['dockerfile', 'nixpacks', 'static', 'dockercompose']).default('nixpacks').describe('Build pack type'),
-        type: z.enum(['public', 'private-github-app', 'private-deploy-key', 'dockerfile', 'docker-image', 'docker-compose']).default('public').describe('Application type'),
-        dockerComposeLocation: z.string().optional().describe('Docker Compose file location relative to repo root'),
-        dockerfileLocation: z.string().optional().describe('Dockerfile location relative to repo root'),
-        baseDirectory: z.string().optional().describe('Base directory for build context'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        const result = await coolify.createApplication({
-          name: args.name,
-          description: args.description,
-          projectUuid: args.projectUuid,
-          environmentUuid: args.environmentUuid,
-          serverUuid: args.serverUuid,
-          type: args.type as any,
-          githubRepoUrl: args.githubRepoUrl,
-          branch: args.branch,
-          buildPack: args.buildPack,
-          dockerComposeLocation: args.dockerComposeLocation,
-          dockerfileLocation: args.dockerfileLocation,
-          baseDirectory: args.baseDirectory,
-        })
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({
-                success: true,
-                message: `Application "${args.name}" created successfully`,
-                uuid: result.value.uuid,
-                nextSteps: [
-                  'Use set_env_vars to configure environment variables',
-                  'Use deploy to start the first deployment',
-                ],
-              }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to create application: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 18. get_resource_usage (placeholder - using status)
-    tool(
-      'get_resource_usage',
-      `Get resource usage for a Coolify application.
-
-Returns current resource consumption metrics.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        // For now, use getApplicationStatus - Coolify API doesn't have a separate resource usage endpoint
-        const result = await coolify.getApplicationStatus(args.uuid)
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, status: result.value }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to get resource usage: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 19. health_check
-    tool(
-      'health_check',
-      `Check if Coolify API is accessible and credentials are valid.
-
-Returns connection status and API version info if available.`,
-      {},
-      async () => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify health check failed: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        // Try to list servers as a health check
-        const result = await coolify.listServers()
-
-        if (isOk(result)) {
-          return {
-            content: [{
-              type: 'text' as const,
-              text: JSON.stringify({ success: true, status: 'healthy', message: 'Coolify API is accessible' }, null, 2),
-            }],
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Health check failed: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-
-    // 20. get_application_details (enhanced get_deployment_status)
-    tool(
-      'get_application_details',
-      `Get detailed information about a Coolify application.
-
-Returns full application configuration including name, description,
-build settings, environment, and deployment status.`,
-      {
-        uuid: z.string().uuid().describe('Application UUID'),
-      },
-      async (args) => {
-        const initResult = await coolify.init()
-        if (isErr(initResult)) {
-          return {
-            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
-            isError: true,
-          }
-        }
-
-        // List all applications and filter by UUID to get full details
-        const result = await coolify.listApplications()
-
-        if (isOk(result)) {
-          const app = result.value.find((a) => a.uuid === args.uuid)
-          if (app) {
-            return {
-              content: [{ type: 'text' as const, text: JSON.stringify({ success: true, application: app }, null, 2) }],
-            }
-          }
-          return {
-            content: [{ type: 'text' as const, text: `Application ${args.uuid} not found` }],
-            isError: true,
-          }
-        }
-
-        return {
-          content: [{ type: 'text' as const, text: `Failed to get application details: ${result.error.message}` }],
-          isError: true,
-        }
-      }
-    ),
-  ],
-})
-
-// Auto-start server when running as main process (not when imported)
-if (import.meta.url === `file://${process.argv[1]}`) {
-  coolifyServer
-}
-
-// Re-export CoolifyService for library usage
-export { getCoolifyService } from './coolify/index.js'
-export type * from './coolify/index.js'
+// ─── SDK: Coolify (primary export) ───────────────────────────────────────────
+
+export { Coolify, type ICoolifyOptions } from "./sdk.js";
+
+// ─── Internal CoolifyService (for MCP/CLI, advanced usage) ──────────────────
+
+export {
+  CoolifyService,
+  getCoolifyService,
+  type ICoolifyEnvVar,
+} from "./coolify/index.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type {
+  ICoolifyServer,
+  ICoolifyServerResource,
+  ICoolifyServerDomain,
+  ICoolifyDestination,
+  ICoolifyProject,
+  ICoolifyTeam,
+  ICoolifyApplication,
+  ICoolifyDatabase,
+  ICoolifyDatabaseBackup,
+  ICoolifyService as ICoolifyServiceType,
+  ICoolifyPrivateKey,
+  ICoolifyDeployment,
+  ICoolifyVersion,
+  ICoolifyAppOptions,
+  ICoolifyAppResult,
+  ICoolifyDeployOptions,
+  ICoolifyDeployResult,
+  ICoolifyDeleteResult,
+  ICoolifyUpdateOptions,
+  ICoolifyLogsOptions,
+  ICoolifyLogs,
+  ICoolifyEnvironment,
+  IProgressCallback,
+  TCoolifyApplicationType,
+} from "./coolify/types.js";
+
+// ─── MCP Tools (for building custom MCP servers) ─────────────────────────────
+
+export { coolifyTools } from "./tools/definitions.js";
+export { handleToolCall } from "./tools/handlers.js";
+
+// ─── Network diagnostics + operation tracing ─────────────────────────────────
+
+export { inspectNetwork, analyzeDeployFailure } from "./network.js";
+export type { INetworkInfo, IDeployFailureAnalysis } from "./network.js";
+export { OperationTracer, isMcpMode } from "./trace.js";
+export type { ITraceStep, IOperationTrace, TraceCallback } from "./trace.js";
+
+// ─── .coolify.json state (for scaffolder integration) ────────────────────────
+
+export {
+  loadCoolifyState,
+  resolveUuid,
+  type ICoolifyDeployState,
+} from "./cli/coolify-state.js";